diff --git a/art/Deliverables/FuseeIconTop64_VS.ico b/art/Deliverables/FuseeIconTop64_VS.ico new file mode 100644 index 000000000..2f649cf97 Binary files /dev/null and b/art/Deliverables/FuseeIconTop64_VS.ico differ diff --git a/art/Deliverables/FuseeIconTop64_VS.png b/art/Deliverables/FuseeIconTop64_VS.png new file mode 100644 index 000000000..904042da2 Binary files /dev/null and b/art/Deliverables/FuseeIconTop64_VS.png differ diff --git a/dis/VSTemplate/Core/Assets/FUSEERocket.fus b/dis/VSTemplate/Core/Assets/FUSEERocket.fus new file mode 100644 index 000000000..5a278d8ac Binary files /dev/null and b/dis/VSTemplate/Core/Assets/FUSEERocket.fus differ diff --git a/dis/VSTemplate/Core/Assets/FuseeText.png b/dis/VSTemplate/Core/Assets/FuseeText.png new file mode 100644 index 000000000..af5ffb051 Binary files /dev/null and b/dis/VSTemplate/Core/Assets/FuseeText.png differ diff --git a/dis/VSTemplate/Core/Assets/Lato-Black.ttf b/dis/VSTemplate/Core/Assets/Lato-Black.ttf new file mode 100644 index 000000000..6848db0d1 Binary files /dev/null and b/dis/VSTemplate/Core/Assets/Lato-Black.ttf differ diff --git a/dis/VSTemplate/Core/Core.cs b/dis/VSTemplate/Core/Core.cs new file mode 100644 index 000000000..177b9ff87 --- /dev/null +++ b/dis/VSTemplate/Core/Core.cs @@ -0,0 +1,217 @@ +using System.Collections.Generic; +using System.Linq; +using Fusee.Base.Common; +using Fusee.Base.Core; +using Fusee.Engine.Common; +using Fusee.Engine.Core; +using Fusee.Math.Core; +using Fusee.Serialization; +using Fusee.Xene; +using static Fusee.Engine.Core.Input; +using static Fusee.Engine.Core.Time; +using Fusee.Engine.GUI; + +namespace $ext_safeprojectname$.Core +{ + [FuseeApplication(Name = "FUSEE Simple Example", Description = "A very simple example.")] + public class Simple : RenderCanvas + { + // angle variables + private static float _angleHorz = M.PiOver3, _angleVert = -M.PiOver6 * 0.5f, _angleVelHorz, _angleVelVert; + + private const float RotationSpeed = 7; + private const float Damping = 0.8f; + + private SceneContainer _rocketScene; + private SceneRendererForward _sceneRenderer; + + private const float ZNear = 1f; + private const float ZFar = 1000; + private float _fovy = M.PiOver4; + + private SceneRendererForward _guiRenderer; + private SceneContainer _gui; + private SceneInteractionHandler _sih; + private readonly CanvasRenderMode _canvasRenderMode = CanvasRenderMode.SCREEN; + + private bool _keys; + + // Init is called on startup. + public override void Init() + { + _gui = CreateGui(); + Resize(new ResizeEventArgs(Width, Height)); + // Create the interaction handler + _sih = new SceneInteractionHandler(_gui); + + // Set the clear color for the backbuffer to white (100% intensity in all color channels R, G, B, A). + RC.ClearColor = new float4(1, 1, 1, 1); + + // Load the rocket model + _rocketScene = AssetStorage.Get("FUSEERocket.fus"); + + // Wrap a SceneRenderer around the model. + _sceneRenderer = new SceneRendererForward(_rocketScene); + _guiRenderer = new SceneRendererForward(_gui); + } + + + // RenderAFrame is called once a frame + public override void RenderAFrame() + { + // Clear the backbuffer + RC.Clear(ClearFlags.Color | ClearFlags.Depth); + + // Mouse and keyboard movement + if (Keyboard.LeftRightAxis != 0 || Keyboard.UpDownAxis != 0) + { + _keys = true; + } + + if (Mouse.LeftButton) + { + _keys = false; + _angleVelHorz = -RotationSpeed * Mouse.XVel * DeltaTime * 0.0005f; + _angleVelVert = -RotationSpeed * Mouse.YVel * DeltaTime * 0.0005f; + } + else if (Touch.GetTouchActive(TouchPoints.Touchpoint_0)) + { + _keys = false; + var touchVel = Touch.GetVelocity(TouchPoints.Touchpoint_0); + _angleVelHorz = -RotationSpeed * touchVel.x * DeltaTime * 0.0005f; + _angleVelVert = -RotationSpeed * touchVel.y * DeltaTime * 0.0005f; + } + else + { + if (_keys) + { + _angleVelHorz = -RotationSpeed * Keyboard.LeftRightAxis * DeltaTime; + _angleVelVert = -RotationSpeed * Keyboard.UpDownAxis * DeltaTime; + } + else + { + var curDamp = (float)System.Math.Exp(-Damping * DeltaTime); + _angleVelHorz *= curDamp; + _angleVelVert *= curDamp; + } + } + + _angleHorz += _angleVelHorz; + _angleVert += _angleVelVert; + + // Create the camera matrix and set it as the current ModelView transformation + var mtxRot = float4x4.CreateRotationX(_angleVert) * float4x4.CreateRotationY(_angleHorz); + var mtxCam = float4x4.LookAt(0, +2, -10, 0, +2, 0, 0, 1, 0); + RC.View = mtxCam * mtxRot; + + //Set the view matrix for the interaction handler. + _sih.View = RC.View; + + // Constantly check for interactive objects. + if(!Mouse.Desc.Contains("Android")) + _sih.CheckForInteractiveObjects(Mouse.Position, Width, Height); + + if (Touch.GetTouchActive(TouchPoints.Touchpoint_0) && !Touch.TwoPoint) + { + _sih.CheckForInteractiveObjects(Touch.GetPosition(TouchPoints.Touchpoint_0), Width, Height); + } + + // Render the scene loaded in Init() + _sceneRenderer.Render(RC); + _guiRenderer.Render(RC); + + // Swap buffers: Show the contents of the backbuffer (containing the currently rendered frame) on the front buffer. + Present(); + } + + private SceneContainer CreateGui() + { + var vsTex = AssetStorage.Get("texture.vert"); + var psTex = AssetStorage.Get("texture.frag"); + + var canvasWidth = Width / 100f; + var canvasHeight = Height / 100f; + + var btnFuseeLogo = new GUIButton + { + Name = "Canvas_Button" + }; + btnFuseeLogo.OnMouseEnter += BtnLogoEnter; + btnFuseeLogo.OnMouseExit += BtnLogoExit; + btnFuseeLogo.OnMouseDown += BtnLogoDown; + + var guiFuseeLogo = new Texture(AssetStorage.Get("FuseeText.png")); + var fuseeLogo = new TextureNodeContainer( + "fuseeLogo", + vsTex, + psTex, + //Set the diffuse texture you want to use. + guiFuseeLogo, + //Define anchor points. They are given in percent, seen from the lower left corner, respectively to the width/height of the parent. + //In this setup the element will stretch horizontally but stay the same vertically if the parent element is scaled. + UIElementPosition.GetAnchors(AnchorPos.TOP_TOP_LEFT), + //Define Offset and therefor the size of the element. + UIElementPosition.CalcOffsets(AnchorPos.TOP_TOP_LEFT, new float2(0, canvasHeight - 0.5f), canvasHeight, canvasWidth, new float2(1.75f, 0.5f)) + ); + fuseeLogo.AddComponent(btnFuseeLogo); + + var fontLato = AssetStorage.Get("Lato-Black.ttf"); + var guiLatoBlack = new FontMap(fontLato, 18); + + var text = new TextNodeContainer( + "FUSEE Simple Example", + "ButtonText", + vsTex, + psTex, + UIElementPosition.GetAnchors(AnchorPos.STRETCH_HORIZONTAL), + UIElementPosition.CalcOffsets(AnchorPos.STRETCH_HORIZONTAL, new float2(canvasWidth / 2 - 4, 0), canvasHeight, canvasWidth, new float2(8, 1)), + guiLatoBlack, + ColorUint.Tofloat4(ColorUint.Greenery), 250f); + + + var canvas = new CanvasNodeContainer( + "Canvas", + _canvasRenderMode, + new MinMaxRect + { + Min = new float2(-canvasWidth / 2, -canvasHeight / 2f), + Max = new float2(canvasWidth / 2, canvasHeight / 2f) + }) + { + Children = new ChildList() + { + //Simple Texture Node, contains the fusee logo. + fuseeLogo, + text + } + }; + + var canvasProjComp = new ProjectionComponent(ProjectionMethod.ORTHOGRAPHIC, ZNear, ZFar, _fovy); + canvas.Components.Insert(0, canvasProjComp); + + return new SceneContainer + { + Children = new List + { + //Add canvas. + canvas + } + }; + } + + public void BtnLogoEnter(CodeComponent sender) + { + _gui.Children.FindNodes(node => node.Name == "fuseeLogo").First().GetComponent().Effect.SetEffectParam("DiffuseColor", new float4(0.8f, 0.8f, 0.8f, 1f)); + } + + public void BtnLogoExit(CodeComponent sender) + { + _gui.Children.FindNodes(node => node.Name == "fuseeLogo").First().GetComponent().Effect.SetEffectParam("DiffuseColor", float4.One); + } + + public void BtnLogoDown(CodeComponent sender) + { + OpenLink("http://fusee3d.org"); + } + } +} \ No newline at end of file diff --git a/dis/VSTemplate/Core/Core.csproj b/dis/VSTemplate/Core/Core.csproj new file mode 100644 index 000000000..00a4b55f9 --- /dev/null +++ b/dis/VSTemplate/Core/Core.csproj @@ -0,0 +1,19 @@ + + + $ext_safeprojectname$.Core + $ext_safeprojectname$.Core + netstandard2.0 + + + + ..\bin\Core + + + + + + + + + + diff --git a/dis/VSTemplate/Core/Core.vstemplate b/dis/VSTemplate/Core/Core.vstemplate new file mode 100644 index 000000000..7d524be28 --- /dev/null +++ b/dis/VSTemplate/Core/Core.vstemplate @@ -0,0 +1,26 @@ + + + FUSEE Core Project + This is a template for a FUSEE core project + CSharp + true + Core + true + Enabled + true + true + __TemplateIcon.ico + __PreviewImage.png + + + + + FUSEERocket.fus + FuseeText.png + Lato-Black.ttf + + Core.cs + NuGet.config + + + \ No newline at end of file diff --git a/dis/VSTemplate/Core/NuGet.config b/dis/VSTemplate/Core/NuGet.config new file mode 100644 index 000000000..0c70f5de3 --- /dev/null +++ b/dis/VSTemplate/Core/NuGet.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/dis/VSTemplate/Core/__PreviewImage.png b/dis/VSTemplate/Core/__PreviewImage.png new file mode 100644 index 000000000..a6d3d4f28 Binary files /dev/null and b/dis/VSTemplate/Core/__PreviewImage.png differ diff --git a/dis/VSTemplate/Core/__TemplateIcon.ico b/dis/VSTemplate/Core/__TemplateIcon.ico new file mode 100644 index 000000000..2f649cf97 Binary files /dev/null and b/dis/VSTemplate/Core/__TemplateIcon.ico differ diff --git a/dis/VSTemplate/Desktop/Desktop.cs b/dis/VSTemplate/Desktop/Desktop.cs new file mode 100644 index 000000000..ba7e32c99 --- /dev/null +++ b/dis/VSTemplate/Desktop/Desktop.cs @@ -0,0 +1,66 @@ +using System.IO; +using System.Runtime.InteropServices; +using Fusee.Base.Common; +using Fusee.Base.Core; +using Fusee.Base.Imp.Desktop; +using Fusee.Engine.Core; +using Fusee.Serialization; +using FileMode = Fusee.Base.Common.FileMode; +using Path = Fusee.Base.Common.Path; +using System.Reflection; +using System; + +namespace $ext_safeprojectname$.Desktop +{ + public class Desktop + { + public static void Main() + { + // Inject Fusee.Engine.Base InjectMe dependencies + IO.IOImp = new Fusee.Base.Imp.Desktop.IOImp(); + + var fap = new Fusee.Base.Imp.Desktop.FileAssetProvider("Assets"); + fap.RegisterTypeHandler( + new AssetHandler + { + ReturnedType = typeof(Font), + Decoder = delegate (string id, object storage) + { + if (!Path.GetExtension(id).ToLower().Contains("ttf")) return null; + return new Font{ _fontImp = new FontImp((Stream)storage) }; + }, + Checker = id => Path.GetExtension(id).ToLower().Contains("ttf") + }); + fap.RegisterTypeHandler( + new AssetHandler + { + ReturnedType = typeof(SceneContainer), + Decoder = delegate (string id, object storage) + { + if (!Path.GetExtension(id).ToLower().Contains("fus")) return null; + return new ConvertSceneGraph().Convert(ProtoBuf.Serializer.Deserialize((Stream)storage)); + }, + Checker = id => Path.GetExtension(id).ToLower().Contains("fus") + }); + + AssetStorage.RegisterProvider(fap); + + var app = new Core.Simple(); + + // Inject Fusee.Engine InjectMe dependencies (hard coded) + System.Drawing.Icon appIcon = System.Drawing.Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location); + app.CanvasImplementor = new Fusee.Engine.Imp.Graphics.Desktop.RenderCanvasImp(appIcon); + app.ContextImplementor = new Fusee.Engine.Imp.Graphics.Desktop.RenderContextImp(app.CanvasImplementor); + Input.AddDriverImp(new Fusee.Engine.Imp.Graphics.Desktop.RenderCanvasInputDriverImp(app.CanvasImplementor)); + Input.AddDriverImp(new Fusee.Engine.Imp.Graphics.Desktop.WindowsTouchInputDriverImp(app.CanvasImplementor)); + // app.InputImplementor = new Fusee.Engine.Imp.Graphics.Desktop.InputImp(app.CanvasImplementor); + // app.AudioImplementor = new Fusee.Engine.Imp.Sound.Desktop.AudioImp(); + // app.NetworkImplementor = new Fusee.Engine.Imp.Network.Desktop.NetworkImp(); + // app.InputDriverImplementor = new Fusee.Engine.Imp.Input.Desktop.InputDriverImp(); + // app.VideoManagerImplementor = ImpFactory.CreateIVideoManagerImp(); + + // Start the app + app.Run(); + } + } +} diff --git a/dis/VSTemplate/Desktop/Desktop.csproj b/dis/VSTemplate/Desktop/Desktop.csproj new file mode 100644 index 000000000..fc4692c4b --- /dev/null +++ b/dis/VSTemplate/Desktop/Desktop.csproj @@ -0,0 +1,28 @@ + + + $ext_safeprojectname$.Desktop + $ext_safeprojectname$.Desktop + netcoreapp3.0 + Exe + PLATFORM_DESKTOP + FuseeLogo.ico + + + + ..\bin\Desktop + + + + + + + + + + + + + Core + + + \ No newline at end of file diff --git a/dis/VSTemplate/Desktop/Desktop.vstemplate b/dis/VSTemplate/Desktop/Desktop.vstemplate new file mode 100644 index 000000000..5bfe9f3fe --- /dev/null +++ b/dis/VSTemplate/Desktop/Desktop.vstemplate @@ -0,0 +1,22 @@ + + + FUSEE Desktop Project + This is a template for a FUSEE desktop project + CSharp + true + Desktop + true + Enabled + true + true + __TemplateIcon.ico + __PreviewImage.png + + + + FuseeLogo.ico + Desktop.cs + NuGet.config + + + \ No newline at end of file diff --git a/dis/VSTemplate/Desktop/FuseeLogo.ico b/dis/VSTemplate/Desktop/FuseeLogo.ico new file mode 100644 index 000000000..dbdc5bc33 Binary files /dev/null and b/dis/VSTemplate/Desktop/FuseeLogo.ico differ diff --git a/dis/VSTemplate/Desktop/NuGet.config b/dis/VSTemplate/Desktop/NuGet.config new file mode 100644 index 000000000..0c70f5de3 --- /dev/null +++ b/dis/VSTemplate/Desktop/NuGet.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/dis/VSTemplate/Desktop/__PreviewImage.png b/dis/VSTemplate/Desktop/__PreviewImage.png new file mode 100644 index 000000000..a6d3d4f28 Binary files /dev/null and b/dis/VSTemplate/Desktop/__PreviewImage.png differ diff --git a/dis/VSTemplate/Desktop/__TemplateIcon.ico b/dis/VSTemplate/Desktop/__TemplateIcon.ico new file mode 100644 index 000000000..2f649cf97 Binary files /dev/null and b/dis/VSTemplate/Desktop/__TemplateIcon.ico differ diff --git a/dis/VSTemplate/Fusee.vstemplate b/dis/VSTemplate/Fusee.vstemplate new file mode 100644 index 000000000..dbefd73bb --- /dev/null +++ b/dis/VSTemplate/Fusee.vstemplate @@ -0,0 +1,22 @@ + + + FUSEE + A Fusee template. + __TemplateIcon.ico + __PreviewImage.png + CSharp + + + + + Desktop\Desktop.vstemplate + + + Core\Core.vstemplate + + + WebAsm\WebAsm.vstemplate + + + + \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/Assets/FuseeAnim.gif b/dis/VSTemplate/WebAsm/Assets/FuseeAnim.gif new file mode 100644 index 000000000..3d2803861 Binary files /dev/null and b/dis/VSTemplate/WebAsm/Assets/FuseeAnim.gif differ diff --git a/dis/VSTemplate/WebAsm/Assets/FuseeSpinning.gif b/dis/VSTemplate/WebAsm/Assets/FuseeSpinning.gif new file mode 100644 index 000000000..0347065b1 Binary files /dev/null and b/dis/VSTemplate/WebAsm/Assets/FuseeSpinning.gif differ diff --git a/dis/VSTemplate/WebAsm/Assets/Styles/browser.css b/dis/VSTemplate/WebAsm/Assets/Styles/browser.css new file mode 100644 index 000000000..01058377f --- /dev/null +++ b/dis/VSTemplate/WebAsm/Assets/Styles/browser.css @@ -0,0 +1,86 @@ +*, html, body { + margin: 0px; + padding: 0px; + +} + +body { + height: 500px; + overflow: hidden; +} + +#feedback-body +{ + position: absolute; + width: 100%; + height: 100%; + z-index: 1000; + background-color: white; +} + +/* CANVAS */ +#canvas { + background-color: black; + border: 0px; + left: 0px; + top: 0px; + image-rendering: optimizeSpeed; + image-rendering: -moz-crisp-edges; + image-rendering: -o-crisp-edges; + image-rendering: -webkit-optimize-contrast; + -ms-interpolation-mode: nearest-neighbor; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + -webkit-user-drag: none; + -moz-user-drag: none; + /* ReSharper disable once CssNotResolved */ + user-drag: none; +} + +/* PROGRESS BAR */ +#loadingProgress { + position: absolute; + width: 100%; + height: 100%; + left: 0%; + top: 0%; + background: white; + opacity: 1; + transition: opacity 1s +} + +#progressBar { + position: absolute; + left: 0%; + top: 99.5%; + height: 0.5%; + border-right: none; + border-left: none; + padding: 0px; + background: #88B04B; + transition: width 0.5s +} + +#progressText { + position: absolute; + text-align: center; + text-shadow: #000000 1px 1px 0px; + overflow: hidden; + text-overflow: ellipsis; + background-color: rgba(0, 0, 0, 0.66); + border-radius: 8px; + color: white; + font-family: Consolas, Courier New, Courier; + font-size: 9pt; + padding-top: 3px; + padding-bottom: 3px; + padding-left: 6px; + padding-right: 6px; + max-width: 90%; + max-height: 1.1em; + visibility: hidden; +} \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/FuseeLogo.ico b/dis/VSTemplate/WebAsm/FuseeLogo.ico new file mode 100644 index 000000000..dbdc5bc33 Binary files /dev/null and b/dis/VSTemplate/WebAsm/FuseeLogo.ico differ diff --git a/dis/VSTemplate/WebAsm/NuGet.config b/dis/VSTemplate/WebAsm/NuGet.config new file mode 100644 index 000000000..0c70f5de3 --- /dev/null +++ b/dis/VSTemplate/WebAsm/NuGet.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/Properties/launchSettings.json b/dis/VSTemplate/WebAsm/Properties/launchSettings.json new file mode 100644 index 000000000..9d40407ef --- /dev/null +++ b/dis/VSTemplate/WebAsm/Properties/launchSettings.json @@ -0,0 +1,12 @@ +{ + "profiles": { + "WebLaunch": { + "commandName": "Executable", + "executablePath": "python.exe", + "commandLineArgs": "server.py", + "workingDirectory": "$(OutputPath)", + "launchBrowser": true, + "launchUrl": "http://localhost:8000/" + } + } +} \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/Scripts/SkiaSharp.js b/dis/VSTemplate/WebAsm/Scripts/SkiaSharp.js new file mode 100644 index 000000000..884eaf3b8 --- /dev/null +++ b/dis/VSTemplate/WebAsm/Scripts/SkiaSharp.js @@ -0,0 +1,32986 @@ +//require(["canvaskit"], (ckInit) => { +// ckInit().then((i) => { +// window.CanvasKit = i; +// MonoSupport.jsCallDispatcher.registerScope("Skia", SkiaSharp.SkiaApi); +// }); +//}); + + +var SkiaSharp; +(function (SkiaSharp) { + class SurfaceManager { + static registerManagedStream() { + SurfaceManager._readInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:ReadInternal"); + SurfaceManager._peekInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:PeekInternal"); + SurfaceManager._isAtEndInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:IsAtEndInternal"); + SurfaceManager._hasPositionInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:HasPositionInternal"); + SurfaceManager._hasLengthInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:HasLengthInternal"); + SurfaceManager._rewindInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:RewindInternal"); + SurfaceManager._getPositionInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:GetPositionInternal"); + SurfaceManager._seekInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:SeekInternal"); + SurfaceManager._moveInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:MoveInternal"); + SurfaceManager._getLengthInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:GetLengthInternal"); + SurfaceManager._createNewInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:CreateNewInternal"); + SurfaceManager._destroyInternal = Module.mono_bind_static_method("[SkiaSharp.Wasm] SkiaSharp.ManagedStreamHelper:DestroyInternal"); + var fRead = CanvasKit.addFunction((managedStreamPtr, buffer, size) => SurfaceManager.readInternal(managedStreamPtr, buffer, size)); + var fPeek = CanvasKit.addFunction((managedStreamPtr, buffer, size) => SurfaceManager.peekInternal(managedStreamPtr, buffer, size)); + var fIsAtEnd = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._isAtEndInternal(managedStreamPtr)); + var fHasPosition = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._hasPositionInternal(managedStreamPtr)); + var fHasLength = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._hasLengthInternal(managedStreamPtr)); + var fRewind = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._rewindInternal(managedStreamPtr)); + var fGetPosition = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._getPositionInternal(managedStreamPtr)); + var fSeek = CanvasKit.addFunction((managedStreamPtr, position) => SurfaceManager._seekInternal(managedStreamPtr, position)); + var fMove = CanvasKit.addFunction((managedStreamPtr, offset) => SurfaceManager._moveInternal(managedStreamPtr, offset)); + var fGetLength = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._getLengthInternal(managedStreamPtr)); + var fCreateNew = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._createNewInternal(managedStreamPtr)); + var fDestroy = CanvasKit.addFunction((managedStreamPtr) => SurfaceManager._destroyInternal(managedStreamPtr)); + CanvasKit._sk_managedstream_set_delegates(fRead, fPeek, fIsAtEnd, fHasPosition, fHasLength, fRewind, fGetPosition, fSeek, fMove, fGetLength, fCreateNew, fDestroy); + return true; + } + static readInternal(managedStreamPtr, buffer, size) { + var ckBuffer = CanvasKit._malloc(size); + try { + var ret = SurfaceManager._readInternal(managedStreamPtr, ckBuffer, size); + for (var i = 0; i < size; i++) { + CanvasKit.HEAPU8[buffer + i] = Module.HEAPU8[ckBuffer + i]; + } + return ret; + } + finally { + CanvasKit._free(ckBuffer); + } + } + static peekInternal(managedStreamPtr, buffer, size) { + var ckBuffer = CanvasKit._malloc(size); + try { + var ret = SurfaceManager._peekInternal(managedStreamPtr, ckBuffer, size); + for (var i = 0; i < size; i++) { + CanvasKit.HEAPU8[buffer + i] = Module.HEAPU8[ckBuffer + i]; + } + return ret; + } + finally { + CanvasKit._free(ckBuffer); + } + } + static invalidateCanvas(pData, canvasId, width, height) { + var c = document.getElementById(canvasId); + c.width = width; + c.height = height; + var ctx = c.getContext("2d"); + var buffer = new Uint8ClampedArray(CanvasKit.HEAPU8.buffer, pData, width * height * 4); + var imageData = new ImageData(buffer, width, height); + ctx.putImageData(imageData, 0, 0); + return true; + } + } + SkiaSharp.SurfaceManager = SurfaceManager; + class ApiOverride { + static memcpy(sourceArray, pSource, destArray, pDest, length) { + destArray.set(sourceArray.slice(pSource, pSource + length), pDest); + } + static memcpy_Mono2Sk(pMono, pSk, length) { + ApiOverride.memcpy(Module.HEAPU8, pMono, CanvasKit.HEAPU8, pSk, length); + } + static memcpy_Sk2Mono(pSk, pMono, length) { + ApiOverride.memcpy(CanvasKit.HEAPU8, pSk, Module.HEAPU8, pMono, length); + } + static sk_bitmap_get_pixels_0_Post(skPixels, parms, retStruct) { + var monoPixels = this.sk2MonoMap[skPixels]; + if (!monoPixels) { + monoPixels = Module._malloc(retStruct.length); + this.sk2MonoMap[skPixels] = monoPixels; + this.mono2SkMap[monoPixels] = skPixels; + this.bitmapPixels[parms.b] = monoPixels; + } + // Synchronize the pixels content + this.memcpy_Sk2Mono(skPixels, monoPixels, retStruct.length); + return monoPixels; + } + static sk_bitmap_destructor_0_Post(ret, parms) { + var monoPixels = this.bitmapPixels[parms.b]; + if (monoPixels) { + delete this.bitmapPixels[parms.b]; + var skPixels = this.mono2SkMap[monoPixels]; + delete this.mono2SkMap[monoPixels]; + delete this.sk2MonoMap[skPixels]; + Module._free(monoPixels); + } + } + static sk_codec_get_pixels_0_Pre(parms) { + var skPixels = this.mono2SkMap[parms.pixels]; + if (skPixels) { + parms.pixels = skPixels; + } + else { + throw `Unknown pixels pointer in sk_codec_get_pixels`; + } + } + static sk_memorystream_set_memory_Pre(parms) { + var skStream = this.memoryStreamMap[parms.s]; + if (!skStream) { + skStream = CanvasKit._malloc(parms.length); + } + // Synchronize the pixels content + this.memcpy_Mono2Sk(parms.data, skStream, parms.length); + parms.data = skStream; + } + static sk_memorystream_destroy_Post(ret, parms) { + var skStream = this.memoryStreamMap[parms.stream]; + if (skStream) { + delete this.memoryStreamMap[parms.stream]; + CanvasKit._free(skStream); + } + return ret; + } + } + ApiOverride.sk2MonoMap = {}; + ApiOverride.mono2SkMap = {}; + ApiOverride.bitmapPixels = {}; + ApiOverride.memoryStreamMap = {}; + SkiaSharp.ApiOverride = ApiOverride; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class GRGlFramebufferInfo { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new GRGlFramebufferInfo(); + { + ret.fboId = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.format = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fboId, "i32"); + memoryContext.setValue(pData + 4, this.format, "i32"); + } + } + SkiaSharp.GRGlFramebufferInfo = GRGlFramebufferInfo; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class GRGlTextureInfo { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new GRGlTextureInfo(); + { + ret.fTarget = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.fID = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fFormat = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fTarget, "i32"); + memoryContext.setValue(pData + 4, this.fID, "i32"); + memoryContext.setValue(pData + 8, this.fFormat, "i32"); + } + } + SkiaSharp.GRGlTextureInfo = GRGlTextureInfo; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKCodecFrameInfo { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKCodecFrameInfo(); + { + ret.requiredFrame = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.duration = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fullyRecieved = Number(memoryContext.getValue(pData + 8, "i8")); + } + { + ret.alphaType = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.disposalMethod = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.requiredFrame, "i32"); + memoryContext.setValue(pData + 4, this.duration, "i32"); + memoryContext.setValue(pData + 8, this.fullyRecieved, "i8"); + memoryContext.setValue(pData + 12, this.alphaType, "i32"); + memoryContext.setValue(pData + 16, this.disposalMethod, "i32"); + } + } + SkiaSharp.SKCodecFrameInfo = SKCodecFrameInfo; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKCodecOptionsInternal { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKCodecOptionsInternal(); + { + ret.fZeroInitialized = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.fSubset = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.fFrameIndex = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.fPriorFrame = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.fPremulBehavior = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fZeroInitialized, "i32"); + memoryContext.setValue(pData + 4, this.fSubset, "*"); + memoryContext.setValue(pData + 8, this.fFrameIndex, "i32"); + memoryContext.setValue(pData + 12, this.fPriorFrame, "i32"); + memoryContext.setValue(pData + 16, this.fPremulBehavior, "i32"); + } + } + SkiaSharp.SKCodecOptionsInternal = SKCodecOptionsInternal; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKColor { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKColor(); + { + ret.color = Number(memoryContext.getValue(pData + 0, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.color, "i32"); + } + } + SkiaSharp.SKColor = SKColor; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKColorSpacePrimaries { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKColorSpacePrimaries(); + { + ret.fRX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.fRY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.fGX = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.fGY = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.fBX = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.fBY = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.fWX = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.fWY = Number(memoryContext.getValue(pData + 28, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fRX, "float"); + memoryContext.setValue(pData + 4, this.fRY, "float"); + memoryContext.setValue(pData + 8, this.fGX, "float"); + memoryContext.setValue(pData + 12, this.fGY, "float"); + memoryContext.setValue(pData + 16, this.fBX, "float"); + memoryContext.setValue(pData + 20, this.fBY, "float"); + memoryContext.setValue(pData + 24, this.fWX, "float"); + memoryContext.setValue(pData + 28, this.fWY, "float"); + } + } + SkiaSharp.SKColorSpacePrimaries = SKColorSpacePrimaries; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKColorSpaceTransferFn { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKColorSpaceTransferFn(); + { + ret.fG = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.fA = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.fB = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.fC = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.fD = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.fE = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.fF = Number(memoryContext.getValue(pData + 24, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fG, "float"); + memoryContext.setValue(pData + 4, this.fA, "float"); + memoryContext.setValue(pData + 8, this.fB, "float"); + memoryContext.setValue(pData + 12, this.fC, "float"); + memoryContext.setValue(pData + 16, this.fD, "float"); + memoryContext.setValue(pData + 20, this.fE, "float"); + memoryContext.setValue(pData + 24, this.fF, "float"); + } + } + SkiaSharp.SKColorSpaceTransferFn = SKColorSpaceTransferFn; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKDocumentPdfMetadataInternal { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKDocumentPdfMetadataInternal(); + { + ret.Title = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.Author = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.Subject = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.Keywords = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.Creator = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.Producer = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.Creation = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.Modified = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.RasterDPI = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.PDFA = Number(memoryContext.getValue(pData + 36, "i8")); + } + { + ret.EncodingQuality = Number(memoryContext.getValue(pData + 40, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.Title, "*"); + memoryContext.setValue(pData + 4, this.Author, "*"); + memoryContext.setValue(pData + 8, this.Subject, "*"); + memoryContext.setValue(pData + 12, this.Keywords, "*"); + memoryContext.setValue(pData + 16, this.Creator, "*"); + memoryContext.setValue(pData + 20, this.Producer, "*"); + memoryContext.setValue(pData + 24, this.Creation, "*"); + memoryContext.setValue(pData + 28, this.Modified, "*"); + memoryContext.setValue(pData + 32, this.RasterDPI, "float"); + memoryContext.setValue(pData + 36, this.PDFA, "i8"); + memoryContext.setValue(pData + 40, this.EncodingQuality, "i32"); + } + } + SkiaSharp.SKDocumentPdfMetadataInternal = SKDocumentPdfMetadataInternal; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKFontMetrics { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKFontMetrics(); + { + ret.flags = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.top = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.ascent = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.descent = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.bottom = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.leading = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.avgCharWidth = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.maxCharWidth = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.xMin = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.xMax = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.xHeight = Number(memoryContext.getValue(pData + 40, "float")); + } + { + ret.capHeight = Number(memoryContext.getValue(pData + 44, "float")); + } + { + ret.underlineThickness = Number(memoryContext.getValue(pData + 48, "float")); + } + { + ret.underlinePosition = Number(memoryContext.getValue(pData + 52, "float")); + } + { + ret.strikeoutThickness = Number(memoryContext.getValue(pData + 56, "float")); + } + { + ret.strikeoutPosition = Number(memoryContext.getValue(pData + 60, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(64); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.flags, "i32"); + memoryContext.setValue(pData + 4, this.top, "float"); + memoryContext.setValue(pData + 8, this.ascent, "float"); + memoryContext.setValue(pData + 12, this.descent, "float"); + memoryContext.setValue(pData + 16, this.bottom, "float"); + memoryContext.setValue(pData + 20, this.leading, "float"); + memoryContext.setValue(pData + 24, this.avgCharWidth, "float"); + memoryContext.setValue(pData + 28, this.maxCharWidth, "float"); + memoryContext.setValue(pData + 32, this.xMin, "float"); + memoryContext.setValue(pData + 36, this.xMax, "float"); + memoryContext.setValue(pData + 40, this.xHeight, "float"); + memoryContext.setValue(pData + 44, this.capHeight, "float"); + memoryContext.setValue(pData + 48, this.underlineThickness, "float"); + memoryContext.setValue(pData + 52, this.underlinePosition, "float"); + memoryContext.setValue(pData + 56, this.strikeoutThickness, "float"); + memoryContext.setValue(pData + 60, this.strikeoutPosition, "float"); + } + } + SkiaSharp.SKFontMetrics = SKFontMetrics; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKHighContrastConfig { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKHighContrastConfig(); + { + ret.fGrayscale = Number(memoryContext.getValue(pData + 0, "i8")); + } + { + ret.fInvertStyle = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fContrast = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fGrayscale, "i8"); + memoryContext.setValue(pData + 4, this.fInvertStyle, "i32"); + memoryContext.setValue(pData + 8, this.fContrast, "float"); + } + } + SkiaSharp.SKHighContrastConfig = SKHighContrastConfig; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKImageInfoNative { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKImageInfoNative(); + { + ret.fColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.fWidth = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fHeight = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.fColorType = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.fAlphaType = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fColorSpace, "*"); + memoryContext.setValue(pData + 4, this.fWidth, "i32"); + memoryContext.setValue(pData + 8, this.fHeight, "i32"); + memoryContext.setValue(pData + 12, this.fColorType, "i32"); + memoryContext.setValue(pData + 16, this.fAlphaType, "i32"); + } + } + SkiaSharp.SKImageInfoNative = SKImageInfoNative; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKJpegEncoderOptions { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKJpegEncoderOptions(); + { + ret.fQuality = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.fDownsample = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fAlphaOption = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.fBlendBehavior = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fQuality, "i32"); + memoryContext.setValue(pData + 4, this.fDownsample, "i32"); + memoryContext.setValue(pData + 8, this.fAlphaOption, "i32"); + memoryContext.setValue(pData + 12, this.fBlendBehavior, "i32"); + } + } + SkiaSharp.SKJpegEncoderOptions = SKJpegEncoderOptions; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKLatticeInternal { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKLatticeInternal(); + { + ret.fXDivs = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.fYDivs = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.fRectTypes = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.fXCount = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.fYCount = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.fBounds = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.fColors = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fXDivs, "*"); + memoryContext.setValue(pData + 4, this.fYDivs, "*"); + memoryContext.setValue(pData + 8, this.fRectTypes, "*"); + memoryContext.setValue(pData + 12, this.fXCount, "i32"); + memoryContext.setValue(pData + 16, this.fYCount, "i32"); + memoryContext.setValue(pData + 20, this.fBounds, "*"); + memoryContext.setValue(pData + 24, this.fColors, "*"); + } + } + SkiaSharp.SKLatticeInternal = SKLatticeInternal; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKMask { + constructor() { + this.bounds = new SkiaSharp.SKRectI(); + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKMask(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bounds = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.format = Number(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.image, "*"); + this.bounds.marshal(pData + 4); + memoryContext.setValue(pData + 20, this.rowBytes, "i32"); + memoryContext.setValue(pData + 24, this.format, "i32"); + } + } + SkiaSharp.SKMask = SKMask; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKMatrix { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKMatrix(); + { + ret.scaleX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.skewX = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.transX = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.skewY = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.scaleY = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.transY = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.persp0 = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.persp1 = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.persp2 = Number(memoryContext.getValue(pData + 32, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.scaleX, "float"); + memoryContext.setValue(pData + 4, this.skewX, "float"); + memoryContext.setValue(pData + 8, this.transX, "float"); + memoryContext.setValue(pData + 12, this.skewY, "float"); + memoryContext.setValue(pData + 16, this.scaleY, "float"); + memoryContext.setValue(pData + 20, this.transY, "float"); + memoryContext.setValue(pData + 24, this.persp0, "float"); + memoryContext.setValue(pData + 28, this.persp1, "float"); + memoryContext.setValue(pData + 32, this.persp2, "float"); + } + } + SkiaSharp.SKMatrix = SKMatrix; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKPMColor { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKPMColor(); + { + ret.color = Number(memoryContext.getValue(pData + 0, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.color, "i32"); + } + } + SkiaSharp.SKPMColor = SKPMColor; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKPngEncoderOptions { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKPngEncoderOptions(); + { + ret.fFilterFlags = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.fZLibLevel = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fUnpremulBehavior = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.fComments = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fFilterFlags, "i32"); + memoryContext.setValue(pData + 4, this.fZLibLevel, "i32"); + memoryContext.setValue(pData + 8, this.fUnpremulBehavior, "i32"); + memoryContext.setValue(pData + 12, this.fComments, "*"); + } + } + SkiaSharp.SKPngEncoderOptions = SKPngEncoderOptions; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKPoint { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKPoint(); + { + ret.x = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.x, "float"); + memoryContext.setValue(pData + 4, this.y, "float"); + } + } + SkiaSharp.SKPoint = SKPoint; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKPoint3 { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKPoint3(); + { + ret.x = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.z = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.x, "float"); + memoryContext.setValue(pData + 4, this.y, "float"); + memoryContext.setValue(pData + 8, this.z, "float"); + } + } + SkiaSharp.SKPoint3 = SKPoint3; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKPointI { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKPointI(); + { + ret.x = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.x, "i32"); + memoryContext.setValue(pData + 4, this.y, "i32"); + } + } + SkiaSharp.SKPointI = SKPointI; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKRect { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKRect(); + { + ret.left = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.top = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.right = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.bottom = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.left, "float"); + memoryContext.setValue(pData + 4, this.top, "float"); + memoryContext.setValue(pData + 8, this.right, "float"); + memoryContext.setValue(pData + 12, this.bottom, "float"); + } + } + SkiaSharp.SKRect = SKRect; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKRectI { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKRectI(); + { + ret.left = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.top = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.right = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.bottom = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.left, "i32"); + memoryContext.setValue(pData + 4, this.top, "i32"); + memoryContext.setValue(pData + 8, this.right, "i32"); + memoryContext.setValue(pData + 12, this.bottom, "i32"); + } + } + SkiaSharp.SKRectI = SKRectI; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKSizeI { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKSizeI(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.width, "i32"); + memoryContext.setValue(pData + 4, this.height, "i32"); + } + } + SkiaSharp.SKSizeI = SKSizeI; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKTextBlobBuilderRunBuffer { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKTextBlobBuilderRunBuffer(); + { + ret.glyphs = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pos = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.utf8text = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.clusters = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.glyphs, "*"); + memoryContext.setValue(pData + 4, this.pos, "*"); + memoryContext.setValue(pData + 8, this.utf8text, "*"); + memoryContext.setValue(pData + 12, this.clusters, "*"); + } + } + SkiaSharp.SKTextBlobBuilderRunBuffer = SKTextBlobBuilderRunBuffer; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class SKWebpEncoderOptions { + constructor() { + } + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new SKWebpEncoderOptions(); + { + ret.fCompression = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.fQuality = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.fUnpremulBehavior = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.fCompression, "i32"); + memoryContext.setValue(pData + 4, this.fQuality, "float"); + memoryContext.setValue(pData + 8, this.fUnpremulBehavior, "i32"); + } + } + SkiaSharp.SKWebpEncoderOptions = SKWebpEncoderOptions; +})(SkiaSharp || (SkiaSharp = {})); +var SkiaSharp; +(function (SkiaSharp) { + class SkiaApi { + static sk_colorspace_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_unref_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_unref(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_unref_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_gamma_close_to_srgb_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_gamma_close_to_srgb_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_close_to_srgb_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_gamma_close_to_srgb_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_gamma_close_to_srgb(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_close_to_srgb_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_gamma_close_to_srgb_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_gamma_is_linear_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_gamma_is_linear_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_is_linear_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_gamma_is_linear_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_gamma_is_linear(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_is_linear_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_gamma_is_linear_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_is_srgb_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_is_srgb_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_is_srgb_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_is_srgb_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_is_srgb(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_is_srgb_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_is_srgb_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_gamma_get_type_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_gamma_get_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_get_type_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_gamma_get_type_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_gamma_get_type(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_get_type_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_gamma_get_type_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_gamma_get_gamma_named_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_gamma_get_gamma_named_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_get_gamma_named_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_gamma_get_gamma_named_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_gamma_get_gamma_named(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_gamma_get_gamma_named_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_gamma_get_gamma_named_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_equals_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_equals_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_equals_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_equals_0_Pre(parms); + } + var src = parms.src; + var dst = parms.dst; + var ret = CanvasKit._sk_colorspace_equals(src, dst); + if (SkiaSharp.ApiOverride.sk_colorspace_equals_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_equals_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_srgb_0(pParams, pReturn) { + var ret = CanvasKit._sk_colorspace_new_srgb(); + if (SkiaSharp.ApiOverride.sk_colorspace_new_srgb_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_srgb_0_Post(ret); + } + return ret; + } + static sk_colorspace_new_srgb_linear_0(pParams, pReturn) { + var ret = CanvasKit._sk_colorspace_new_srgb_linear(); + if (SkiaSharp.ApiOverride.sk_colorspace_new_srgb_linear_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_srgb_linear_0_Post(ret); + } + return ret; + } + static sk_colorspace_new_icc_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_icc_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_icc_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_icc_0_Pre(parms); + } + var input = parms.input; + var len = parms.len; + var ret = CanvasKit._sk_colorspace_new_icc(input, len); + if (SkiaSharp.ApiOverride.sk_colorspace_new_icc_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_icc_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_icc_1(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_icc_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_icc_1_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_icc_1_Pre(parms); + } + var input = CanvasKit._malloc(parms.input_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.input_Length; i++) { + CanvasKit.HEAPU8[input + i] = parms.input[i]; + } + } + var len = parms.len; + var ret = CanvasKit._sk_colorspace_new_icc(input, len); + if (SkiaSharp.ApiOverride.sk_colorspace_new_icc_1_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_icc_1_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_rgb_with_gamma_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_rgb_with_gamma_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_0_Pre(parms); + } + var gamma = parms.gamma; + var toXYZD50 = parms.toXYZD50; + var ret = CanvasKit._sk_colorspace_new_rgb_with_gamma(gamma, toXYZD50); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_rgb_with_gamma_and_gamut_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Pre(parms); + } + var gamma = parms.gamma; + var gamut = parms.gamut; + var ret = CanvasKit._sk_colorspace_new_rgb_with_gamma_and_gamut(gamma, gamut); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_rgb_with_coeffs_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspace_new_rgb_with_coeffs_0_Return(); + var parms = SkiaSharp.sk_colorspace_new_rgb_with_coeffs_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_0_Pre(parms); + } + var coeffs = parms.coeffs.marshalNew(CanvasKit); + var toXYZD50 = parms.toXYZD50; + var ret = CanvasKit._sk_colorspace_new_rgb_with_coeffs(coeffs, toXYZD50); + var retStruct = new SkiaSharp.sk_colorspace_new_rgb_with_coeffs_0_Return(); + retStruct.coeffs = SkiaSharp.SKColorSpaceTransferFn.unmarshal(coeffs, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colorspace_new_rgb_with_coeffs_and_gamut_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Return(); + var parms = SkiaSharp.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Pre(parms); + } + var coeffs = parms.coeffs.marshalNew(CanvasKit); + var gamut = parms.gamut; + var ret = CanvasKit._sk_colorspace_new_rgb_with_coeffs_and_gamut(coeffs, gamut); + var retStruct = new SkiaSharp.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Return(); + retStruct.coeffs = SkiaSharp.SKColorSpaceTransferFn.unmarshal(coeffs, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colorspace_new_rgb_with_gamma_named_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_rgb_with_gamma_named_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_0_Pre(parms); + } + var gamma = parms.gamma; + var toXYZD50 = parms.toXYZD50; + var ret = CanvasKit._sk_colorspace_new_rgb_with_gamma_named(gamma, toXYZD50); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_new_rgb_with_gamma_named_and_gamut_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Pre(parms); + } + var gamma = parms.gamma; + var gamut = parms.gamut; + var ret = CanvasKit._sk_colorspace_new_rgb_with_gamma_named_and_gamut(gamma, gamut); + if (SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_to_xyzd50_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_to_xyzd50_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_to_xyzd50_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_to_xyzd50_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var toXYZD50 = parms.toXYZD50; + var ret = CanvasKit._sk_colorspace_to_xyzd50(cColorSpace, toXYZD50); + if (SkiaSharp.ApiOverride.sk_colorspace_to_xyzd50_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_to_xyzd50_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_as_to_xyzd50_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_as_to_xyzd50_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_as_to_xyzd50_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_as_to_xyzd50_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_as_to_xyzd50(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_as_to_xyzd50_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_as_to_xyzd50_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_as_from_xyzd50_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorspace_as_from_xyzd50_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_as_from_xyzd50_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_as_from_xyzd50_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var ret = CanvasKit._sk_colorspace_as_from_xyzd50(cColorSpace); + if (SkiaSharp.ApiOverride.sk_colorspace_as_from_xyzd50_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_as_from_xyzd50_0_Post(ret, parms); + } + return ret; + } + static sk_colorspace_is_numerical_transfer_fn_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspace_is_numerical_transfer_fn_0_Return(); + var parms = SkiaSharp.sk_colorspace_is_numerical_transfer_fn_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_is_numerical_transfer_fn_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_is_numerical_transfer_fn_0_Pre(parms); + } + var cColorSpace = parms.cColorSpace; + var fn = retStruct.fn.marshalNew(CanvasKit); + var ret = CanvasKit._sk_colorspace_is_numerical_transfer_fn(cColorSpace, fn); + var retStruct = new SkiaSharp.sk_colorspace_is_numerical_transfer_fn_0_Return(); + retStruct.fn = SkiaSharp.SKColorSpaceTransferFn.unmarshal(fn, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspace_is_numerical_transfer_fn_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_is_numerical_transfer_fn_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colorspaceprimaries_to_xyzd50_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspaceprimaries_to_xyzd50_0_Return(); + var parms = SkiaSharp.sk_colorspaceprimaries_to_xyzd50_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspaceprimaries_to_xyzd50_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspaceprimaries_to_xyzd50_0_Pre(parms); + } + var primaries = parms.primaries.marshalNew(CanvasKit); + var toXYZD50 = parms.toXYZD50; + var ret = CanvasKit._sk_colorspaceprimaries_to_xyzd50(primaries, toXYZD50); + var retStruct = new SkiaSharp.sk_colorspaceprimaries_to_xyzd50_0_Return(); + retStruct.primaries = SkiaSharp.SKColorSpacePrimaries.unmarshal(primaries, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspaceprimaries_to_xyzd50_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspaceprimaries_to_xyzd50_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colorspace_transfer_fn_invert_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspace_transfer_fn_invert_0_Return(); + var parms = SkiaSharp.sk_colorspace_transfer_fn_invert_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_invert_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_invert_0_Pre(parms); + } + var transfer = parms.transfer.marshalNew(CanvasKit); + var inverted = retStruct.inverted.marshalNew(CanvasKit); + var ret = CanvasKit._sk_colorspace_transfer_fn_invert(transfer, inverted); + var retStruct = new SkiaSharp.sk_colorspace_transfer_fn_invert_0_Return(); + retStruct.transfer = SkiaSharp.SKColorSpaceTransferFn.unmarshal(transfer, CanvasKit); + retStruct.inverted = SkiaSharp.SKColorSpaceTransferFn.unmarshal(inverted, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_invert_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_invert_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colorspace_transfer_fn_transform_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorspace_transfer_fn_transform_0_Return(); + var parms = SkiaSharp.sk_colorspace_transfer_fn_transform_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_transform_0_Pre) { + SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_transform_0_Pre(parms); + } + var transfer = parms.transfer.marshalNew(CanvasKit); + var x = parms.x; + var ret = CanvasKit._sk_colorspace_transfer_fn_transform(transfer, x); + var retStruct = new SkiaSharp.sk_colorspace_transfer_fn_transform_0_Return(); + retStruct.transfer = SkiaSharp.SKColorSpaceTransferFn.unmarshal(transfer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_transform_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorspace_transfer_fn_transform_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_colortype_get_default_8888_0(pParams, pReturn) { + var ret = CanvasKit._sk_colortype_get_default_8888(); + if (SkiaSharp.ApiOverride.sk_colortype_get_default_8888_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colortype_get_default_8888_0_Post(ret); + } + return ret; + } + static sk_surface_new_null_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_new_null_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_null_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_null_0_Pre(parms); + } + var width = parms.width; + var height = parms.height; + var ret = CanvasKit._sk_surface_new_null(width, height); + if (SkiaSharp.ApiOverride.sk_surface_new_null_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_null_0_Post(ret, parms); + } + return ret; + } + static sk_surface_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_unref_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_surface_unref(t); + if (SkiaSharp.ApiOverride.sk_surface_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_unref_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_raster_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_surface_new_raster_0_Return(); + var parms = SkiaSharp.sk_surface_new_raster_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_raster_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_raster_0_Pre(parms); + } + var info = parms.info.marshalNew(CanvasKit); + var rowBytes = parms.rowBytes; + var props = parms.props; + var ret = CanvasKit._sk_surface_new_raster(info, rowBytes, props); + var retStruct = new SkiaSharp.sk_surface_new_raster_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_surface_new_raster_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_raster_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_surface_new_raster_direct_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_surface_new_raster_direct_0_Return(); + var parms = SkiaSharp.sk_surface_new_raster_direct_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_raster_direct_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_raster_direct_0_Pre(parms); + } + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var releaseProc = parms.releaseProc; + var context = parms.context; + var props = parms.props; + var ret = CanvasKit._sk_surface_new_raster_direct(info, pixels, rowBytes, releaseProc, context, props); + var retStruct = new SkiaSharp.sk_surface_new_raster_direct_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_surface_new_raster_direct_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_raster_direct_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_surface_get_canvas_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_get_canvas_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_get_canvas_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_get_canvas_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_surface_get_canvas(t); + if (SkiaSharp.ApiOverride.sk_surface_get_canvas_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_get_canvas_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_image_snapshot_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_new_image_snapshot_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_image_snapshot_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_image_snapshot_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_surface_new_image_snapshot(t); + if (SkiaSharp.ApiOverride.sk_surface_new_image_snapshot_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_image_snapshot_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_backend_render_target_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_new_backend_render_target_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_render_target_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_backend_render_target_0_Pre(parms); + } + var context = parms.context; + var target = parms.target; + var origin = parms.origin; + var colorType = parms.colorType; + var colorspace = parms.colorspace; + var props = parms.props; + var ret = CanvasKit._sk_surface_new_backend_render_target(context, target, origin, colorType, colorspace, props); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_render_target_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_backend_render_target_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_backend_texture_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_new_backend_texture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_texture_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_backend_texture_0_Pre(parms); + } + var context = parms.context; + var texture = parms.texture; + var origin = parms.origin; + var samples = parms.samples; + var colorType = parms.colorType; + var colorspace = parms.colorspace; + var props = parms.props; + var ret = CanvasKit._sk_surface_new_backend_texture(context, texture, origin, samples, colorType, colorspace, props); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_texture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_backend_texture_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_backend_texture_as_render_target_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_new_backend_texture_as_render_target_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_texture_as_render_target_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_backend_texture_as_render_target_0_Pre(parms); + } + var context = parms.context; + var texture = parms.texture; + var origin = parms.origin; + var samples = parms.samples; + var colorType = parms.colorType; + var colorspace = parms.colorspace; + var props = parms.props; + var ret = CanvasKit._sk_surface_new_backend_texture_as_render_target(context, texture, origin, samples, colorType, colorspace, props); + if (SkiaSharp.ApiOverride.sk_surface_new_backend_texture_as_render_target_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_backend_texture_as_render_target_0_Post(ret, parms); + } + return ret; + } + static sk_surface_new_render_target_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_surface_new_render_target_0_Return(); + var parms = SkiaSharp.sk_surface_new_render_target_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_new_render_target_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_new_render_target_0_Pre(parms); + } + var context = parms.context; + var budgeted = parms.budgeted; + var info = parms.info.marshalNew(CanvasKit); + var sampleCount = parms.sampleCount; + var origin = parms.origin; + var props = parms.props; + var shouldCreateWithMips = parms.shouldCreateWithMips; + var ret = CanvasKit._sk_surface_new_render_target(context, budgeted, info, sampleCount, origin, props, shouldCreateWithMips); + var retStruct = new SkiaSharp.sk_surface_new_render_target_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_surface_new_render_target_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_new_render_target_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_surface_draw_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_draw_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_draw_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_draw_0_Pre(parms); + } + var surface = parms.surface; + var canvas = parms.canvas; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_surface_draw(surface, canvas, x, y, paint); + if (SkiaSharp.ApiOverride.sk_surface_draw_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_draw_0_Post(ret, parms); + } + return ret; + } + static sk_surface_peek_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_peek_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_peek_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_peek_pixels_0_Pre(parms); + } + var surface = parms.surface; + var pixmap = parms.pixmap; + var ret = CanvasKit._sk_surface_peek_pixels(surface, pixmap); + if (SkiaSharp.ApiOverride.sk_surface_peek_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_peek_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_surface_read_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_surface_read_pixels_0_Return(); + var parms = SkiaSharp.sk_surface_read_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_read_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_read_pixels_0_Pre(parms); + } + var surface = parms.surface; + var dstInfo = parms.dstInfo.marshalNew(CanvasKit); + var dstPixels = parms.dstPixels; + var dstRowBytes = parms.dstRowBytes; + var srcX = parms.srcX; + var srcY = parms.srcY; + var ret = CanvasKit._sk_surface_read_pixels(surface, dstInfo, dstPixels, dstRowBytes, srcX, srcY); + var retStruct = new SkiaSharp.sk_surface_read_pixels_0_Return(); + retStruct.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(dstInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_surface_read_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_read_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_surface_get_props_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surface_get_props_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surface_get_props_0_Pre) { + SkiaSharp.ApiOverride.sk_surface_get_props_0_Pre(parms); + } + var surface = parms.surface; + var ret = CanvasKit._sk_surface_get_props(surface); + if (SkiaSharp.ApiOverride.sk_surface_get_props_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surface_get_props_0_Post(ret, parms); + } + return ret; + } + static sk_surfaceprops_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surfaceprops_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surfaceprops_new_0_Pre) { + SkiaSharp.ApiOverride.sk_surfaceprops_new_0_Pre(parms); + } + var flags = parms.flags; + var geometry = parms.geometry; + var ret = CanvasKit._sk_surfaceprops_new(flags, geometry); + if (SkiaSharp.ApiOverride.sk_surfaceprops_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surfaceprops_new_0_Post(ret, parms); + } + return ret; + } + static sk_surfaceprops_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surfaceprops_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surfaceprops_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_surfaceprops_delete_0_Pre(parms); + } + var props = parms.props; + var ret = CanvasKit._sk_surfaceprops_delete(props); + if (SkiaSharp.ApiOverride.sk_surfaceprops_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surfaceprops_delete_0_Post(ret, parms); + } + return ret; + } + static sk_surfaceprops_get_flags_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surfaceprops_get_flags_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surfaceprops_get_flags_0_Pre) { + SkiaSharp.ApiOverride.sk_surfaceprops_get_flags_0_Pre(parms); + } + var props = parms.props; + var ret = CanvasKit._sk_surfaceprops_get_flags(props); + if (SkiaSharp.ApiOverride.sk_surfaceprops_get_flags_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surfaceprops_get_flags_0_Post(ret, parms); + } + return ret; + } + static sk_surfaceprops_get_pixel_geometry_0(pParams, pReturn) { + var parms = SkiaSharp.sk_surfaceprops_get_pixel_geometry_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_surfaceprops_get_pixel_geometry_0_Pre) { + SkiaSharp.ApiOverride.sk_surfaceprops_get_pixel_geometry_0_Pre(parms); + } + var props = parms.props; + var ret = CanvasKit._sk_surfaceprops_get_pixel_geometry(props); + if (SkiaSharp.ApiOverride.sk_surfaceprops_get_pixel_geometry_0_Post) { + ret = SkiaSharp.ApiOverride.sk_surfaceprops_get_pixel_geometry_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_save_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_save_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_save_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_save_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_canvas_save(t); + if (SkiaSharp.ApiOverride.sk_canvas_save_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_save_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_save_layer_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_save_layer_0_Return(); + var parms = SkiaSharp.sk_canvas_save_layer_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_save_layer_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_save_layer_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_save_layer(t, rect, paint); + var retStruct = new SkiaSharp.sk_canvas_save_layer_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_save_layer_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_save_layer_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_save_layer_1(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_save_layer_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_save_layer_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_save_layer_1_Pre(parms); + } + var t = parms.t; + var rectZero = parms.rectZero; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_save_layer(t, rectZero, paint); + if (SkiaSharp.ApiOverride.sk_canvas_save_layer_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_save_layer_1_Post(ret, parms); + } + return ret; + } + static sk_canvas_restore_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_restore_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_restore_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_restore_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_canvas_restore(t); + if (SkiaSharp.ApiOverride.sk_canvas_restore_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_restore_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_get_save_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_get_save_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_get_save_count_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_get_save_count_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_canvas_get_save_count(t); + if (SkiaSharp.ApiOverride.sk_canvas_get_save_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_get_save_count_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_restore_to_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_restore_to_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_restore_to_count_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_restore_to_count_0_Pre(parms); + } + var t = parms.t; + var saveCount = parms.saveCount; + var ret = CanvasKit._sk_canvas_restore_to_count(t, saveCount); + if (SkiaSharp.ApiOverride.sk_canvas_restore_to_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_restore_to_count_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_translate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_translate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_translate_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_translate_0_Pre(parms); + } + var t = parms.t; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_canvas_translate(t, dx, dy); + if (SkiaSharp.ApiOverride.sk_canvas_translate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_translate_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_scale_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_scale_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_scale_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_scale_0_Pre(parms); + } + var t = parms.t; + var sx = parms.sx; + var sy = parms.sy; + var ret = CanvasKit._sk_canvas_scale(t, sx, sy); + if (SkiaSharp.ApiOverride.sk_canvas_scale_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_scale_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_rotate_degrees_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_rotate_degrees_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_rotate_degrees_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_rotate_degrees_0_Pre(parms); + } + var t = parms.t; + var degrees = parms.degrees; + var ret = CanvasKit._sk_canvas_rotate_degrees(t, degrees); + if (SkiaSharp.ApiOverride.sk_canvas_rotate_degrees_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_rotate_degrees_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_rotate_radians_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_rotate_radians_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_rotate_radians_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_rotate_radians_0_Pre(parms); + } + var t = parms.t; + var radians = parms.radians; + var ret = CanvasKit._sk_canvas_rotate_radians(t, radians); + if (SkiaSharp.ApiOverride.sk_canvas_rotate_radians_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_rotate_radians_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_skew_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_skew_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_skew_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_skew_0_Pre(parms); + } + var t = parms.t; + var sx = parms.sx; + var sy = parms.sy; + var ret = CanvasKit._sk_canvas_skew(t, sx, sy); + if (SkiaSharp.ApiOverride.sk_canvas_skew_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_skew_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_concat_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_concat_0_Return(); + var parms = SkiaSharp.sk_canvas_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_concat_0_Pre(parms); + } + var t = parms.t; + var m = parms.m.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_concat(t, m); + var retStruct = new SkiaSharp.sk_canvas_concat_0_Return(); + retStruct.m = SkiaSharp.SKMatrix.unmarshal(m, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_concat_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_quick_reject_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_quick_reject_0_Return(); + var parms = SkiaSharp.sk_canvas_quick_reject_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_quick_reject_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_quick_reject_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_quick_reject(t, rect); + var retStruct = new SkiaSharp.sk_canvas_quick_reject_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_quick_reject_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_quick_reject_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_paint_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_paint_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_paint_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_paint_0_Pre(parms); + } + var t = parms.t; + var p = parms.p; + var ret = CanvasKit._sk_canvas_draw_paint(t, p); + if (SkiaSharp.ApiOverride.sk_canvas_draw_paint_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_paint_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_region_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_region_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_region_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_region_0_Pre(parms); + } + var t = parms.t; + var region = parms.region; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_region(t, region, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_region_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_region_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_rect_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_rect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_rect(t, rect, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_rrect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_rrect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_rrect_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_rrect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_rrect(t, rect, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_rrect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_rrect_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_round_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_round_rect_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_round_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_round_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_round_rect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var rx = parms.rx; + var ry = parms.ry; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_round_rect(t, rect, rx, ry, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_round_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_round_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_round_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_oval_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_oval_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_oval_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_oval_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_oval_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_oval(t, rect, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_oval_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_oval_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_oval_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_circle_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_circle_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_circle_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_circle_0_Pre(parms); + } + var t = parms.t; + var cx = parms.cx; + var cy = parms.cy; + var radius = parms.radius; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_circle(t, cx, cy, radius, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_circle_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_circle_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_path_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_path_0_Pre(parms); + } + var t = parms.t; + var path = parms.path; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_path(t, path, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_path_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_image_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_image_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_image_0_Pre(parms); + } + var t = parms.t; + var image = parms.image; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_image(t, image, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_image_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_image_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_image_rect_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_image_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_0_Pre(parms); + } + var t = parms.t; + var image = parms.image; + var src = parms.src.marshalNew(CanvasKit); + var dest = parms.dest.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_image_rect(t, image, src, dest, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_image_rect_0_Return(); + retStruct.src = SkiaSharp.SKRect.unmarshal(src, CanvasKit); + retStruct.dest = SkiaSharp.SKRect.unmarshal(dest, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_image_rect_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_image_rect_1_Return(); + var parms = SkiaSharp.sk_canvas_draw_image_rect_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_1_Pre(parms); + } + var t = parms.t; + var image = parms.image; + var srcZero = parms.srcZero; + var dest = parms.dest.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_image_rect(t, image, srcZero, dest, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_image_rect_1_Return(); + retStruct.dest = SkiaSharp.SKRect.unmarshal(dest, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_image_rect_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_picture_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_picture_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_picture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_picture_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_picture_0_Pre(parms); + } + var t = parms.t; + var pict = parms.pict; + var mat = parms.mat.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_picture(t, pict, mat, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_picture_0_Return(); + retStruct.mat = SkiaSharp.SKMatrix.unmarshal(mat, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_picture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_picture_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_picture_1(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_picture_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_picture_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_picture_1_Pre(parms); + } + var t = parms.t; + var pict = parms.pict; + var matZero = parms.matZero; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_picture(t, pict, matZero, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_picture_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_picture_1_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_drawable_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_drawable_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_drawable_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_drawable_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_drawable_0_Pre(parms); + } + var t = parms.t; + var drawable = parms.drawable; + var mat = parms.mat.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_draw_drawable(t, drawable, mat); + var retStruct = new SkiaSharp.sk_canvas_draw_drawable_0_Return(); + retStruct.mat = SkiaSharp.SKMatrix.unmarshal(mat, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_drawable_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_drawable_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_color_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_color_0_Pre(parms); + } + var t = parms.t; + var color = parms.color.color; + var mode = parms.mode; + var ret = CanvasKit._sk_canvas_draw_color(t, color, mode); + if (SkiaSharp.ApiOverride.sk_canvas_draw_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_color_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_points_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_points_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_points_0_Pre(parms); + } + var t = parms.t; + var mode = parms.mode; + var count = parms.count; + var points = parms.points; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_points(t, mode, count, points, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_points_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_point_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_point_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_point_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_point_0_Pre(parms); + } + var t = parms.t; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_point(t, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_point_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_point_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_line_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_line_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_line_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_line_0_Pre(parms); + } + var t = parms.t; + var x0 = parms.x0; + var y0 = parms.y0; + var x1 = parms.x1; + var y1 = parms.y1; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_line(t, x0, y0, x1, y1, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_line_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_line_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_text_0_Pre(parms); + } + var t = parms.t; + var text = CanvasKit._malloc(parms.text_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.text_Length; i++) { + CanvasKit.HEAPU8[text + i] = parms.text[i]; + } + } + var len = parms.len; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_text(t, text, len, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_text_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_text_1(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_text_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_text_1_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var len = parms.len; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_text(t, text, len, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_text_1_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_pos_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_pos_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_0_Pre(parms); + } + var t = parms.t; + var text = CanvasKit._malloc(parms.text_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.text_Length; i++) { + CanvasKit.HEAPU8[text + i] = parms.text[i]; + } + } + var len = parms.len; + var points = parms.points; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_pos_text(t, text, len, points, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_pos_text_1(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_pos_text_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_1_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var len = parms.len; + var points = parms.points; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_pos_text(t, text, len, points, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_pos_text_1_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_text_on_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_text_on_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_0_Pre(parms); + } + var t = parms.t; + var text = CanvasKit._malloc(parms.text_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.text_Length; i++) { + CanvasKit.HEAPU8[text + i] = parms.text[i]; + } + } + var len = parms.len; + var path = parms.path; + var hOffset = parms.hOffset; + var vOffset = parms.vOffset; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_text_on_path(t, text, len, path, hOffset, vOffset, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_text_on_path_1(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_text_on_path_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_1_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var len = parms.len; + var path = parms.path; + var hOffset = parms.hOffset; + var vOffset = parms.vOffset; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_text_on_path(t, text, len, path, hOffset, vOffset, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_text_on_path_1_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_text_blob_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_text_blob_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_blob_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_text_blob_0_Pre(parms); + } + var canvas = parms.canvas; + var text = parms.text; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_text_blob(canvas, text, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_text_blob_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_text_blob_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_bitmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_bitmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_0_Pre(parms); + } + var t = parms.t; + var bitmap = parms.bitmap; + var x = parms.x; + var y = parms.y; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_bitmap(t, bitmap, x, y, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_bitmap_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_rect_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_bitmap_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_0_Pre(parms); + } + var t = parms.t; + var bitmap = parms.bitmap; + var src = parms.src.marshalNew(CanvasKit); + var dest = parms.dest.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_bitmap_rect(t, bitmap, src, dest, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_rect_0_Return(); + retStruct.src = SkiaSharp.SKRect.unmarshal(src, CanvasKit); + retStruct.dest = SkiaSharp.SKRect.unmarshal(dest, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_bitmap_rect_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_rect_1_Return(); + var parms = SkiaSharp.sk_canvas_draw_bitmap_rect_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_1_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_1_Pre(parms); + } + var t = parms.t; + var bitmap = parms.bitmap; + var srcZero = parms.srcZero; + var dest = parms.dest.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_bitmap_rect(t, bitmap, srcZero, dest, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_rect_1_Return(); + retStruct.dest = SkiaSharp.SKRect.unmarshal(dest, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_1_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_rect_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_reset_matrix_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_reset_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_reset_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_reset_matrix_0_Pre(parms); + } + var canvas = parms.canvas; + var ret = CanvasKit._sk_canvas_reset_matrix(canvas); + if (SkiaSharp.ApiOverride.sk_canvas_reset_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_reset_matrix_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_set_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_set_matrix_0_Return(); + var parms = SkiaSharp.sk_canvas_set_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_set_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_set_matrix_0_Pre(parms); + } + var canvas = parms.canvas; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_set_matrix(canvas, matrix); + var retStruct = new SkiaSharp.sk_canvas_set_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_set_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_set_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_get_total_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_get_total_matrix_0_Return(); + var parms = SkiaSharp.sk_canvas_get_total_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_get_total_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_get_total_matrix_0_Pre(parms); + } + var canvas = parms.canvas; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_get_total_matrix(canvas, matrix); + var retStruct = new SkiaSharp.sk_canvas_get_total_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_get_total_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_get_total_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_annotation_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_annotation_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_annotation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_annotation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_annotation_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var key = CanvasKit._malloc(parms.key_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.key_Length; i++) { + CanvasKit.HEAPU8[key + i] = parms.key[i]; + } + } + var value = parms.value; + var ret = CanvasKit._sk_canvas_draw_annotation(t, rect, key, value); + var retStruct = new SkiaSharp.sk_canvas_draw_annotation_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_annotation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_annotation_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_url_annotation_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_url_annotation_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_url_annotation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_url_annotation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_url_annotation_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var value = parms.value; + var ret = CanvasKit._sk_canvas_draw_url_annotation(t, rect, value); + var retStruct = new SkiaSharp.sk_canvas_draw_url_annotation_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_url_annotation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_url_annotation_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_named_destination_annotation_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_named_destination_annotation_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_named_destination_annotation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_named_destination_annotation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_named_destination_annotation_0_Pre(parms); + } + var t = parms.t; + var point = parms.point.marshalNew(CanvasKit); + var value = parms.value; + var ret = CanvasKit._sk_canvas_draw_named_destination_annotation(t, point, value); + var retStruct = new SkiaSharp.sk_canvas_draw_named_destination_annotation_0_Return(); + retStruct.point = SkiaSharp.SKPoint.unmarshal(point, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_named_destination_annotation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_named_destination_annotation_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_link_destination_annotation_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_link_destination_annotation_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_link_destination_annotation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_link_destination_annotation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_link_destination_annotation_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var value = parms.value; + var ret = CanvasKit._sk_canvas_draw_link_destination_annotation(t, rect, value); + var retStruct = new SkiaSharp.sk_canvas_draw_link_destination_annotation_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_link_destination_annotation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_link_destination_annotation_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_clip_rrect_with_operation_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_clip_rrect_with_operation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_clip_rrect_with_operation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_clip_rrect_with_operation_0_Pre(parms); + } + var t = parms.t; + var crect = parms.crect; + var op = parms.op; + var doAA = parms.doAA; + var ret = CanvasKit._sk_canvas_clip_rrect_with_operation(t, crect, op, doAA); + if (SkiaSharp.ApiOverride.sk_canvas_clip_rrect_with_operation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_clip_rrect_with_operation_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_clip_rect_with_operation_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_clip_rect_with_operation_0_Return(); + var parms = SkiaSharp.sk_canvas_clip_rect_with_operation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_clip_rect_with_operation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_clip_rect_with_operation_0_Pre(parms); + } + var t = parms.t; + var crect = parms.crect.marshalNew(CanvasKit); + var op = parms.op; + var doAA = parms.doAA; + var ret = CanvasKit._sk_canvas_clip_rect_with_operation(t, crect, op, doAA); + var retStruct = new SkiaSharp.sk_canvas_clip_rect_with_operation_0_Return(); + retStruct.crect = SkiaSharp.SKRect.unmarshal(crect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_clip_rect_with_operation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_clip_rect_with_operation_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_clip_path_with_operation_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_clip_path_with_operation_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_clip_path_with_operation_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_clip_path_with_operation_0_Pre(parms); + } + var t = parms.t; + var cpath = parms.cpath; + var op = parms.op; + var doAA = parms.doAA; + var ret = CanvasKit._sk_canvas_clip_path_with_operation(t, cpath, op, doAA); + if (SkiaSharp.ApiOverride.sk_canvas_clip_path_with_operation_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_clip_path_with_operation_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_clip_region_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_clip_region_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_clip_region_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_clip_region_0_Pre(parms); + } + var t = parms.t; + var region = parms.region; + var op = parms.op; + var ret = CanvasKit._sk_canvas_clip_region(t, region, op); + if (SkiaSharp.ApiOverride.sk_canvas_clip_region_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_clip_region_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_get_device_clip_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_get_device_clip_bounds_0_Return(); + var parms = SkiaSharp.sk_canvas_get_device_clip_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_get_device_clip_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_get_device_clip_bounds_0_Pre(parms); + } + var t = parms.t; + var cbounds = retStruct.cbounds.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_get_device_clip_bounds(t, cbounds); + var retStruct = new SkiaSharp.sk_canvas_get_device_clip_bounds_0_Return(); + retStruct.cbounds = SkiaSharp.SKRectI.unmarshal(cbounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_get_device_clip_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_get_device_clip_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_get_local_clip_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_get_local_clip_bounds_0_Return(); + var parms = SkiaSharp.sk_canvas_get_local_clip_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_get_local_clip_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_get_local_clip_bounds_0_Pre(parms); + } + var t = parms.t; + var cbounds = retStruct.cbounds.marshalNew(CanvasKit); + var ret = CanvasKit._sk_canvas_get_local_clip_bounds(t, cbounds); + var retStruct = new SkiaSharp.sk_canvas_get_local_clip_bounds_0_Return(); + retStruct.cbounds = SkiaSharp.SKRect.unmarshal(cbounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_get_local_clip_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_get_local_clip_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_new_from_bitmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_new_from_bitmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_new_from_bitmap_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_new_from_bitmap_0_Pre(parms); + } + var bitmap = parms.bitmap; + var ret = CanvasKit._sk_canvas_new_from_bitmap(bitmap); + if (SkiaSharp.ApiOverride.sk_canvas_new_from_bitmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_new_from_bitmap_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_flush_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_flush_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_flush_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_flush_0_Pre(parms); + } + var canvas = parms.canvas; + var ret = CanvasKit._sk_canvas_flush(canvas); + if (SkiaSharp.ApiOverride.sk_canvas_flush_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_flush_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_bitmap_lattice_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_lattice_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_bitmap_lattice_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_lattice_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_lattice_0_Pre(parms); + } + var t = parms.t; + var bitmap = parms.bitmap; + var lattice = parms.lattice.marshalNew(CanvasKit); + var dst = parms.dst.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_bitmap_lattice(t, bitmap, lattice, dst, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_lattice_0_Return(); + retStruct.lattice = SkiaSharp.SKLatticeInternal.unmarshal(lattice, CanvasKit); + retStruct.dst = SkiaSharp.SKRect.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_lattice_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_lattice_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_image_lattice_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_image_lattice_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_image_lattice_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_lattice_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_image_lattice_0_Pre(parms); + } + var t = parms.t; + var image = parms.image; + var lattice = parms.lattice.marshalNew(CanvasKit); + var dst = parms.dst.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_image_lattice(t, image, lattice, dst, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_image_lattice_0_Return(); + retStruct.lattice = SkiaSharp.SKLatticeInternal.unmarshal(lattice, CanvasKit); + retStruct.dst = SkiaSharp.SKRect.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_lattice_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_image_lattice_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_bitmap_nine_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_nine_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_bitmap_nine_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_nine_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_nine_0_Pre(parms); + } + var t = parms.t; + var bitmap = parms.bitmap; + var center = parms.center.marshalNew(CanvasKit); + var dst = parms.dst.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_bitmap_nine(t, bitmap, center, dst, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_bitmap_nine_0_Return(); + retStruct.center = SkiaSharp.SKRectI.unmarshal(center, CanvasKit); + retStruct.dst = SkiaSharp.SKRect.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_nine_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_bitmap_nine_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_draw_image_nine_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_canvas_draw_image_nine_0_Return(); + var parms = SkiaSharp.sk_canvas_draw_image_nine_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_nine_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_image_nine_0_Pre(parms); + } + var t = parms.t; + var image = parms.image; + var center = parms.center.marshalNew(CanvasKit); + var dst = parms.dst.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_image_nine(t, image, center, dst, paint); + var retStruct = new SkiaSharp.sk_canvas_draw_image_nine_0_Return(); + retStruct.center = SkiaSharp.SKRectI.unmarshal(center, CanvasKit); + retStruct.dst = SkiaSharp.SKRect.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_canvas_draw_image_nine_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_image_nine_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_canvas_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_destroy_0_Pre(parms); + } + var canvas = parms.canvas; + var ret = CanvasKit._sk_canvas_destroy(canvas); + if (SkiaSharp.ApiOverride.sk_canvas_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_canvas_draw_vertices_0(pParams, pReturn) { + var parms = SkiaSharp.sk_canvas_draw_vertices_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_canvas_draw_vertices_0_Pre) { + SkiaSharp.ApiOverride.sk_canvas_draw_vertices_0_Pre(parms); + } + var canvas = parms.canvas; + var vertices = parms.vertices; + var mode = parms.mode; + var paint = parms.paint; + var ret = CanvasKit._sk_canvas_draw_vertices(canvas, vertices, mode, paint); + if (SkiaSharp.ApiOverride.sk_canvas_draw_vertices_0_Post) { + ret = SkiaSharp.ApiOverride.sk_canvas_draw_vertices_0_Post(ret, parms); + } + return ret; + } + static sk_nodraw_canvas_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nodraw_canvas_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nodraw_canvas_new_0_Pre) { + SkiaSharp.ApiOverride.sk_nodraw_canvas_new_0_Pre(parms); + } + var width = parms.width; + var height = parms.height; + var ret = CanvasKit._sk_nodraw_canvas_new(width, height); + if (SkiaSharp.ApiOverride.sk_nodraw_canvas_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nodraw_canvas_new_0_Post(ret, parms); + } + return ret; + } + static sk_nodraw_canvas_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nodraw_canvas_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nodraw_canvas_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_nodraw_canvas_destroy_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_nodraw_canvas_destroy(t); + if (SkiaSharp.ApiOverride.sk_nodraw_canvas_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nodraw_canvas_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_nway_canvas_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nway_canvas_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nway_canvas_new_0_Pre) { + SkiaSharp.ApiOverride.sk_nway_canvas_new_0_Pre(parms); + } + var width = parms.width; + var height = parms.height; + var ret = CanvasKit._sk_nway_canvas_new(width, height); + if (SkiaSharp.ApiOverride.sk_nway_canvas_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nway_canvas_new_0_Post(ret, parms); + } + return ret; + } + static sk_nway_canvas_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nway_canvas_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nway_canvas_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_nway_canvas_destroy_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_nway_canvas_destroy(t); + if (SkiaSharp.ApiOverride.sk_nway_canvas_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nway_canvas_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_nway_canvas_add_canvas_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nway_canvas_add_canvas_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nway_canvas_add_canvas_0_Pre) { + SkiaSharp.ApiOverride.sk_nway_canvas_add_canvas_0_Pre(parms); + } + var t = parms.t; + var canvas = parms.canvas; + var ret = CanvasKit._sk_nway_canvas_add_canvas(t, canvas); + if (SkiaSharp.ApiOverride.sk_nway_canvas_add_canvas_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nway_canvas_add_canvas_0_Post(ret, parms); + } + return ret; + } + static sk_nway_canvas_remove_canvas_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nway_canvas_remove_canvas_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nway_canvas_remove_canvas_0_Pre) { + SkiaSharp.ApiOverride.sk_nway_canvas_remove_canvas_0_Pre(parms); + } + var t = parms.t; + var canvas = parms.canvas; + var ret = CanvasKit._sk_nway_canvas_remove_canvas(t, canvas); + if (SkiaSharp.ApiOverride.sk_nway_canvas_remove_canvas_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nway_canvas_remove_canvas_0_Post(ret, parms); + } + return ret; + } + static sk_nway_canvas_remove_all_0(pParams, pReturn) { + var parms = SkiaSharp.sk_nway_canvas_remove_all_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_nway_canvas_remove_all_0_Pre) { + SkiaSharp.ApiOverride.sk_nway_canvas_remove_all_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_nway_canvas_remove_all(t); + if (SkiaSharp.ApiOverride.sk_nway_canvas_remove_all_0_Post) { + ret = SkiaSharp.ApiOverride.sk_nway_canvas_remove_all_0_Post(ret, parms); + } + return ret; + } + static sk_overdraw_canvas_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_overdraw_canvas_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_overdraw_canvas_new_0_Pre) { + SkiaSharp.ApiOverride.sk_overdraw_canvas_new_0_Pre(parms); + } + var canvas = parms.canvas; + var ret = CanvasKit._sk_overdraw_canvas_new(canvas); + if (SkiaSharp.ApiOverride.sk_overdraw_canvas_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_overdraw_canvas_new_0_Post(ret, parms); + } + return ret; + } + static sk_overdraw_canvas_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_overdraw_canvas_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_overdraw_canvas_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_overdraw_canvas_destroy_0_Pre(parms); + } + var canvas = parms.canvas; + var ret = CanvasKit._sk_overdraw_canvas_destroy(canvas); + if (SkiaSharp.ApiOverride.sk_overdraw_canvas_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_overdraw_canvas_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_paint_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_paint_new(); + if (SkiaSharp.ApiOverride.sk_paint_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_new_0_Post(ret); + } + return ret; + } + static sk_paint_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_delete_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_delete(t); + if (SkiaSharp.ApiOverride.sk_paint_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_delete_0_Post(ret, parms); + } + return ret; + } + static sk_paint_reset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_reset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_reset_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_reset_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_reset(t); + if (SkiaSharp.ApiOverride.sk_paint_reset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_reset_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_antialias_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_antialias_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_antialias_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_antialias_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_is_antialias(t); + if (SkiaSharp.ApiOverride.sk_paint_is_antialias_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_antialias_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_antialias_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_antialias_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_antialias_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_antialias_0_Pre(parms); + } + var t = parms.t; + var v = parms.v; + var ret = CanvasKit._sk_paint_set_antialias(t, v); + if (SkiaSharp.ApiOverride.sk_paint_set_antialias_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_antialias_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_dither_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_dither_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_dither_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_dither_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_is_dither(t); + if (SkiaSharp.ApiOverride.sk_paint_is_dither_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_dither_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_dither_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_dither_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_dither_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_dither_0_Pre(parms); + } + var t = parms.t; + var v = parms.v; + var ret = CanvasKit._sk_paint_set_dither(t, v); + if (SkiaSharp.ApiOverride.sk_paint_set_dither_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_dither_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_verticaltext_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_verticaltext_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_verticaltext_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_verticaltext_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_is_verticaltext(t); + if (SkiaSharp.ApiOverride.sk_paint_is_verticaltext_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_verticaltext_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_verticaltext_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_verticaltext_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_verticaltext_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_verticaltext_0_Pre(parms); + } + var t = parms.t; + var v = parms.v; + var ret = CanvasKit._sk_paint_set_verticaltext(t, v); + if (SkiaSharp.ApiOverride.sk_paint_set_verticaltext_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_verticaltext_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_color_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_color_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_color(t); + if (SkiaSharp.ApiOverride.sk_paint_get_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_color_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_color_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_color_0_Pre(parms); + } + var t = parms.t; + var color = parms.color.color; + var ret = CanvasKit._sk_paint_set_color(t, color); + if (SkiaSharp.ApiOverride.sk_paint_set_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_color_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_style_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_style_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_style(t); + if (SkiaSharp.ApiOverride.sk_paint_get_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_style_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_style_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_style_0_Pre(parms); + } + var t = parms.t; + var style = parms.style; + var ret = CanvasKit._sk_paint_set_style(t, style); + if (SkiaSharp.ApiOverride.sk_paint_set_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_style_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_stroke_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_stroke_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_width_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_stroke_width_0_Pre(parms); + } + var paint = parms.paint; + var ret = CanvasKit._sk_paint_get_stroke_width(paint); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_stroke_width_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_stroke_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_stroke_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_width_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_stroke_width_0_Pre(parms); + } + var t = parms.t; + var width = parms.width; + var ret = CanvasKit._sk_paint_set_stroke_width(t, width); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_stroke_width_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_stroke_miter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_stroke_miter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_miter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_stroke_miter_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_stroke_miter(t); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_miter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_stroke_miter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_stroke_miter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_stroke_miter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_miter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_stroke_miter_0_Pre(parms); + } + var t = parms.t; + var miter = parms.miter; + var ret = CanvasKit._sk_paint_set_stroke_miter(t, miter); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_miter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_stroke_miter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_stroke_cap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_stroke_cap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_cap_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_stroke_cap_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_stroke_cap(t); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_cap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_stroke_cap_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_stroke_cap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_stroke_cap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_cap_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_stroke_cap_0_Pre(parms); + } + var t = parms.t; + var cap = parms.cap; + var ret = CanvasKit._sk_paint_set_stroke_cap(t, cap); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_cap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_stroke_cap_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_stroke_join_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_stroke_join_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_join_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_stroke_join_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_stroke_join(t); + if (SkiaSharp.ApiOverride.sk_paint_get_stroke_join_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_stroke_join_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_stroke_join_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_stroke_join_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_join_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_stroke_join_0_Pre(parms); + } + var t = parms.t; + var join = parms.join; + var ret = CanvasKit._sk_paint_set_stroke_join(t, join); + if (SkiaSharp.ApiOverride.sk_paint_set_stroke_join_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_stroke_join_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_shader_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_shader_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_shader_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_shader_0_Pre(parms); + } + var t = parms.t; + var shader = parms.shader; + var ret = CanvasKit._sk_paint_set_shader(t, shader); + if (SkiaSharp.ApiOverride.sk_paint_set_shader_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_shader_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_shader_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_shader_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_shader_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_shader_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_shader(t); + if (SkiaSharp.ApiOverride.sk_paint_get_shader_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_shader_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_maskfilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_maskfilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_maskfilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_maskfilter_0_Pre(parms); + } + var t = parms.t; + var filter = parms.filter; + var ret = CanvasKit._sk_paint_set_maskfilter(t, filter); + if (SkiaSharp.ApiOverride.sk_paint_set_maskfilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_maskfilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_maskfilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_maskfilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_maskfilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_maskfilter_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_maskfilter(t); + if (SkiaSharp.ApiOverride.sk_paint_get_maskfilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_maskfilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_colorfilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_colorfilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_colorfilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_colorfilter_0_Pre(parms); + } + var t = parms.t; + var filter = parms.filter; + var ret = CanvasKit._sk_paint_set_colorfilter(t, filter); + if (SkiaSharp.ApiOverride.sk_paint_set_colorfilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_colorfilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_colorfilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_colorfilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_colorfilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_colorfilter_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_colorfilter(t); + if (SkiaSharp.ApiOverride.sk_paint_get_colorfilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_colorfilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_imagefilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_imagefilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_imagefilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_imagefilter_0_Pre(parms); + } + var t = parms.t; + var filter = parms.filter; + var ret = CanvasKit._sk_paint_set_imagefilter(t, filter); + if (SkiaSharp.ApiOverride.sk_paint_set_imagefilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_imagefilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_imagefilter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_imagefilter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_imagefilter_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_imagefilter_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_imagefilter(t); + if (SkiaSharp.ApiOverride.sk_paint_get_imagefilter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_imagefilter_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_blendmode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_blendmode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_blendmode_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_blendmode_0_Pre(parms); + } + var t = parms.t; + var mode = parms.mode; + var ret = CanvasKit._sk_paint_set_blendmode(t, mode); + if (SkiaSharp.ApiOverride.sk_paint_set_blendmode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_blendmode_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_blendmode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_blendmode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_blendmode_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_blendmode_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_blendmode(t); + if (SkiaSharp.ApiOverride.sk_paint_get_blendmode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_blendmode_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_filter_quality_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_filter_quality_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_filter_quality_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_filter_quality_0_Pre(parms); + } + var t = parms.t; + var filterQuality = parms.filterQuality; + var ret = CanvasKit._sk_paint_set_filter_quality(t, filterQuality); + if (SkiaSharp.ApiOverride.sk_paint_set_filter_quality_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_filter_quality_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_filter_quality_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_filter_quality_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_filter_quality_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_filter_quality_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_filter_quality(t); + if (SkiaSharp.ApiOverride.sk_paint_get_filter_quality_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_filter_quality_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_typeface_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_typeface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_typeface_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_typeface_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_typeface(t); + if (SkiaSharp.ApiOverride.sk_paint_get_typeface_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_typeface_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_typeface_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_typeface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_typeface_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_typeface_0_Pre(parms); + } + var t = parms.t; + var typeface = parms.typeface; + var ret = CanvasKit._sk_paint_set_typeface(t, typeface); + if (SkiaSharp.ApiOverride.sk_paint_set_typeface_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_typeface_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_textsize_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_textsize_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_textsize_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_textsize_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_textsize(t); + if (SkiaSharp.ApiOverride.sk_paint_get_textsize_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_textsize_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_textsize_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_textsize_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_textsize_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_textsize_0_Pre(parms); + } + var t = parms.t; + var size = parms.size; + var ret = CanvasKit._sk_paint_set_textsize(t, size); + if (SkiaSharp.ApiOverride.sk_paint_set_textsize_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_textsize_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_align_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_align_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_align_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_align_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_text_align(t); + if (SkiaSharp.ApiOverride.sk_paint_get_text_align_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_align_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_text_align_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_text_align_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_text_align_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_text_align_0_Pre(parms); + } + var t = parms.t; + var align = parms.align; + var ret = CanvasKit._sk_paint_set_text_align(t, align); + if (SkiaSharp.ApiOverride.sk_paint_set_text_align_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_text_align_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_encoding_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_encoding_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_encoding_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_encoding_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_text_encoding(t); + if (SkiaSharp.ApiOverride.sk_paint_get_text_encoding_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_encoding_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_text_encoding_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_text_encoding_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_text_encoding_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_text_encoding_0_Pre(parms); + } + var t = parms.t; + var encoding = parms.encoding; + var ret = CanvasKit._sk_paint_set_text_encoding(t, encoding); + if (SkiaSharp.ApiOverride.sk_paint_set_text_encoding_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_text_encoding_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_scale_x_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_scale_x_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_scale_x_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_scale_x_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_text_scale_x(t); + if (SkiaSharp.ApiOverride.sk_paint_get_text_scale_x_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_scale_x_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_text_scale_x_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_text_scale_x_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_text_scale_x_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_text_scale_x_0_Pre(parms); + } + var t = parms.t; + var scale = parms.scale; + var ret = CanvasKit._sk_paint_set_text_scale_x(t, scale); + if (SkiaSharp.ApiOverride.sk_paint_set_text_scale_x_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_text_scale_x_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_skew_x_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_skew_x_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_skew_x_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_skew_x_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_paint_get_text_skew_x(t); + if (SkiaSharp.ApiOverride.sk_paint_get_text_skew_x_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_skew_x_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_text_skew_x_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_text_skew_x_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_text_skew_x_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_text_skew_x_0_Pre(parms); + } + var t = parms.t; + var skew = parms.skew; + var ret = CanvasKit._sk_paint_set_text_skew_x(t, skew); + if (SkiaSharp.ApiOverride.sk_paint_set_text_skew_x_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_text_skew_x_0_Post(ret, parms); + } + return ret; + } + static sk_paint_measure_text_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_paint_measure_text_0_Return(); + var parms = SkiaSharp.sk_paint_measure_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_measure_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_measure_text_0_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var length = parms.length; + var bounds = parms.bounds.marshalNew(CanvasKit); + var ret = CanvasKit._sk_paint_measure_text(t, text, length, bounds); + var retStruct = new SkiaSharp.sk_paint_measure_text_0_Return(); + retStruct.bounds = SkiaSharp.SKRect.unmarshal(bounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_paint_measure_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_measure_text_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_paint_measure_text_1(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_measure_text_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_measure_text_1_Pre) { + SkiaSharp.ApiOverride.sk_paint_measure_text_1_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var length = parms.length; + var boundsZero = parms.boundsZero; + var ret = CanvasKit._sk_paint_measure_text(t, text, length, boundsZero); + if (SkiaSharp.ApiOverride.sk_paint_measure_text_1_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_measure_text_1_Post(ret, parms); + } + return ret; + } + static sk_paint_break_text_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_paint_break_text_0_Return(); + var parms = SkiaSharp.sk_paint_break_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_break_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_break_text_0_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var length = parms.length; + var maxWidth = parms.maxWidth; + var measuredWidth = CanvasKit._malloc(4); + var ret = CanvasKit._sk_paint_break_text(t, text, length, maxWidth, measuredWidth); + var retStruct = new SkiaSharp.sk_paint_break_text_0_Return(); + retStruct.measuredWidth = CanvasKit.getValue(measuredWidth, "float"); + if (SkiaSharp.ApiOverride.sk_paint_break_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_break_text_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_paint_get_text_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_path_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_path_0_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var length = parms.length; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_paint_get_text_path(t, text, length, x, y); + if (SkiaSharp.ApiOverride.sk_paint_get_text_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_path_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_pos_text_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_pos_text_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_path_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_pos_text_path_0_Pre(parms); + } + var t = parms.t; + var text = parms.text; + var length = parms.length; + var points = parms.points; + var ret = CanvasKit._sk_paint_get_pos_text_path(t, text, length, points); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_pos_text_path_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_fontmetrics_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_paint_get_fontmetrics_0_Return(); + var parms = SkiaSharp.sk_paint_get_fontmetrics_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_0_Pre(parms); + } + var t = parms.t; + var fontMetrics = retStruct.fontMetrics.marshalNew(CanvasKit); + var scale = parms.scale; + var ret = CanvasKit._sk_paint_get_fontmetrics(t, fontMetrics, scale); + var retStruct = new SkiaSharp.sk_paint_get_fontmetrics_0_Return(); + retStruct.fontMetrics = SkiaSharp.SKFontMetrics.unmarshal(fontMetrics, CanvasKit); + if (SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_paint_get_fontmetrics_1(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_fontmetrics_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_1_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_1_Pre(parms); + } + var t = parms.t; + var fontMetricsZero = parms.fontMetricsZero; + var scale = parms.scale; + var ret = CanvasKit._sk_paint_get_fontmetrics(t, fontMetricsZero, scale); + if (SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_1_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_fontmetrics_1_Post(ret, parms); + } + return ret; + } + static sk_paint_get_path_effect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_path_effect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_path_effect_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_path_effect_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_get_path_effect(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_get_path_effect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_path_effect_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_path_effect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_path_effect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_path_effect_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_path_effect_0_Pre(parms); + } + var cpaint = parms.cpaint; + var effect = parms.effect; + var ret = CanvasKit._sk_paint_set_path_effect(cpaint, effect); + if (SkiaSharp.ApiOverride.sk_paint_set_path_effect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_path_effect_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_linear_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_linear_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_linear_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_linear_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_linear_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_linear_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_linear_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_linear_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_linear_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_linear_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_linear_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var linearText = parms.linearText; + var ret = CanvasKit._sk_paint_set_linear_text(cpaint, linearText); + if (SkiaSharp.ApiOverride.sk_paint_set_linear_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_linear_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_subpixel_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_subpixel_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_subpixel_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_subpixel_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_subpixel_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_subpixel_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_subpixel_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_subpixel_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_subpixel_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_subpixel_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_subpixel_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var subpixelText = parms.subpixelText; + var ret = CanvasKit._sk_paint_set_subpixel_text(cpaint, subpixelText); + if (SkiaSharp.ApiOverride.sk_paint_set_subpixel_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_subpixel_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_lcd_render_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_lcd_render_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_lcd_render_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_lcd_render_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_lcd_render_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_lcd_render_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_lcd_render_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_lcd_render_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_lcd_render_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_lcd_render_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_lcd_render_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var lcdText = parms.lcdText; + var ret = CanvasKit._sk_paint_set_lcd_render_text(cpaint, lcdText); + if (SkiaSharp.ApiOverride.sk_paint_set_lcd_render_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_lcd_render_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_embedded_bitmap_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_embedded_bitmap_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_embedded_bitmap_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_embedded_bitmap_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_embedded_bitmap_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_embedded_bitmap_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_embedded_bitmap_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_embedded_bitmap_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_embedded_bitmap_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_embedded_bitmap_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_embedded_bitmap_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var useEmbeddedBitmapText = parms.useEmbeddedBitmapText; + var ret = CanvasKit._sk_paint_set_embedded_bitmap_text(cpaint, useEmbeddedBitmapText); + if (SkiaSharp.ApiOverride.sk_paint_set_embedded_bitmap_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_embedded_bitmap_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_autohinted_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_autohinted_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_autohinted_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_autohinted_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_autohinted(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_autohinted_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_autohinted_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_autohinted_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_autohinted_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_autohinted_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_autohinted_0_Pre(parms); + } + var cpaint = parms.cpaint; + var useAutohinter = parms.useAutohinter; + var ret = CanvasKit._sk_paint_set_autohinted(cpaint, useAutohinter); + if (SkiaSharp.ApiOverride.sk_paint_set_autohinted_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_autohinted_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_hinting_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_hinting_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_hinting_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_hinting_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_get_hinting(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_get_hinting_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_hinting_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_hinting_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_hinting_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_hinting_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_hinting_0_Pre(parms); + } + var cpaint = parms.cpaint; + var hintingLevel = parms.hintingLevel; + var ret = CanvasKit._sk_paint_set_hinting(cpaint, hintingLevel); + if (SkiaSharp.ApiOverride.sk_paint_set_hinting_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_hinting_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_fake_bold_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_fake_bold_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_fake_bold_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_fake_bold_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_fake_bold_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_fake_bold_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_fake_bold_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_fake_bold_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_fake_bold_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_fake_bold_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_fake_bold_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var fakeBoldText = parms.fakeBoldText; + var ret = CanvasKit._sk_paint_set_fake_bold_text(cpaint, fakeBoldText); + if (SkiaSharp.ApiOverride.sk_paint_set_fake_bold_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_fake_bold_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_is_dev_kern_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_is_dev_kern_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_is_dev_kern_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_is_dev_kern_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_is_dev_kern_text(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_is_dev_kern_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_is_dev_kern_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_set_dev_kern_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_set_dev_kern_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_set_dev_kern_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_set_dev_kern_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var devKernText = parms.devKernText; + var ret = CanvasKit._sk_paint_set_dev_kern_text(cpaint, devKernText); + if (SkiaSharp.ApiOverride.sk_paint_set_dev_kern_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_set_dev_kern_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_fill_path_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_paint_get_fill_path_0_Return(); + var parms = SkiaSharp.sk_paint_get_fill_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_fill_path_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_fill_path_0_Pre(parms); + } + var paint = parms.paint; + var src = parms.src; + var dst = parms.dst; + var cullRect = parms.cullRect.marshalNew(CanvasKit); + var resScale = parms.resScale; + var ret = CanvasKit._sk_paint_get_fill_path(paint, src, dst, cullRect, resScale); + var retStruct = new SkiaSharp.sk_paint_get_fill_path_0_Return(); + retStruct.cullRect = SkiaSharp.SKRect.unmarshal(cullRect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_paint_get_fill_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_fill_path_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_paint_get_fill_path_1(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_fill_path_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_fill_path_1_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_fill_path_1_Pre(parms); + } + var paint = parms.paint; + var src = parms.src; + var dst = parms.dst; + var cullRectZero = parms.cullRectZero; + var resScale = parms.resScale; + var ret = CanvasKit._sk_paint_get_fill_path(paint, src, dst, cullRectZero, resScale); + if (SkiaSharp.ApiOverride.sk_paint_get_fill_path_1_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_fill_path_1_Post(ret, parms); + } + return ret; + } + static sk_paint_clone_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_clone_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_clone_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_clone_0_Pre(parms); + } + var cpaint = parms.cpaint; + var ret = CanvasKit._sk_paint_clone(cpaint); + if (SkiaSharp.ApiOverride.sk_paint_clone_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_clone_0_Post(ret, parms); + } + return ret; + } + static sk_paint_text_to_glyphs_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_text_to_glyphs_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_text_to_glyphs_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_text_to_glyphs_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var glyphs = parms.glyphs; + var ret = CanvasKit._sk_paint_text_to_glyphs(cpaint, text, byteLength, glyphs); + if (SkiaSharp.ApiOverride.sk_paint_text_to_glyphs_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_text_to_glyphs_0_Post(ret, parms); + } + return ret; + } + static sk_paint_contains_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_contains_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_contains_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_contains_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var ret = CanvasKit._sk_paint_contains_text(cpaint, text, byteLength); + if (SkiaSharp.ApiOverride.sk_paint_contains_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_contains_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_count_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_count_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_count_text_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_count_text_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var ret = CanvasKit._sk_paint_count_text(cpaint, text, byteLength); + if (SkiaSharp.ApiOverride.sk_paint_count_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_count_text_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_widths_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_widths_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_widths_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_widths_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var widths = parms.widths; + var bounds = parms.bounds; + var ret = CanvasKit._sk_paint_get_text_widths(cpaint, text, byteLength, widths, bounds); + if (SkiaSharp.ApiOverride.sk_paint_get_text_widths_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_widths_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_text_intercepts_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_text_intercepts_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_text_intercepts_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_text_intercepts_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var x = parms.x; + var y = parms.y; + var bounds = CanvasKit._malloc(parms.bounds_Length * 4); /*float*/ + var bounds_f32 = bounds / 4; + { + for (var i = 0; i < parms.bounds_Length; i++) { + CanvasKit.HEAPF32[bounds_f32 + i] = parms.bounds[i]; + } + } + var intervals = parms.intervals; + var ret = CanvasKit._sk_paint_get_text_intercepts(cpaint, text, byteLength, x, y, bounds, intervals); + if (SkiaSharp.ApiOverride.sk_paint_get_text_intercepts_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_text_intercepts_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_pos_text_intercepts_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_pos_text_intercepts_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_intercepts_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_pos_text_intercepts_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var pos = parms.pos; + var bounds = CanvasKit._malloc(parms.bounds_Length * 4); /*float*/ + var bounds_f32 = bounds / 4; + { + for (var i = 0; i < parms.bounds_Length; i++) { + CanvasKit.HEAPF32[bounds_f32 + i] = parms.bounds[i]; + } + } + var intervals = parms.intervals; + var ret = CanvasKit._sk_paint_get_pos_text_intercepts(cpaint, text, byteLength, pos, bounds, intervals); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_intercepts_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_pos_text_intercepts_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_pos_text_h_intercepts_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_pos_text_h_intercepts_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_h_intercepts_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_pos_text_h_intercepts_0_Pre(parms); + } + var cpaint = parms.cpaint; + var text = parms.text; + var byteLength = parms.byteLength; + var xpos = CanvasKit._malloc(parms.xpos_Length * 4); /*float*/ + var xpos_f32 = xpos / 4; + { + for (var i = 0; i < parms.xpos_Length; i++) { + CanvasKit.HEAPF32[xpos_f32 + i] = parms.xpos[i]; + } + } + var y = parms.y; + var bounds = CanvasKit._malloc(parms.bounds_Length * 4); /*float*/ + var bounds_f32 = bounds / 4; + { + for (var i = 0; i < parms.bounds_Length; i++) { + CanvasKit.HEAPF32[bounds_f32 + i] = parms.bounds[i]; + } + } + var intervals = parms.intervals; + var ret = CanvasKit._sk_paint_get_pos_text_h_intercepts(cpaint, text, byteLength, xpos, y, bounds, intervals); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_h_intercepts_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_pos_text_h_intercepts_0_Post(ret, parms); + } + return ret; + } + static sk_paint_get_pos_text_blob_intercepts_0(pParams, pReturn) { + var parms = SkiaSharp.sk_paint_get_pos_text_blob_intercepts_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_blob_intercepts_0_Pre) { + SkiaSharp.ApiOverride.sk_paint_get_pos_text_blob_intercepts_0_Pre(parms); + } + var cpaint = parms.cpaint; + var blob = parms.blob; + var bounds = CanvasKit._malloc(parms.bounds_Length * 4); /*float*/ + var bounds_f32 = bounds / 4; + { + for (var i = 0; i < parms.bounds_Length; i++) { + CanvasKit.HEAPF32[bounds_f32 + i] = parms.bounds[i]; + } + } + var intervals = parms.intervals; + var ret = CanvasKit._sk_paint_get_pos_text_blob_intercepts(cpaint, blob, bounds, intervals); + if (SkiaSharp.ApiOverride.sk_paint_get_pos_text_blob_intercepts_0_Post) { + ret = SkiaSharp.ApiOverride.sk_paint_get_pos_text_blob_intercepts_0_Post(ret, parms); + } + return ret; + } + static sk_image_ref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_ref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_ref_0_Pre) { + SkiaSharp.ApiOverride.sk_image_ref_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_ref(image); + if (SkiaSharp.ApiOverride.sk_image_ref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_ref_0_Post(ret, parms); + } + return ret; + } + static sk_image_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_image_unref_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_unref(image); + if (SkiaSharp.ApiOverride.sk_image_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_unref_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_raster_copy_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_new_raster_copy_0_Return(); + var parms = SkiaSharp.sk_image_new_raster_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_raster_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_raster_copy_0_Pre(parms); + } + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_image_new_raster_copy(info, pixels, rowBytes); + var retStruct = new SkiaSharp.sk_image_new_raster_copy_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_new_raster_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_raster_copy_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_new_raster_copy_with_pixmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_raster_copy_with_pixmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_raster_copy_with_pixmap_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_raster_copy_with_pixmap_0_Pre(parms); + } + var pixmap = parms.pixmap; + var ret = CanvasKit._sk_image_new_raster_copy_with_pixmap(pixmap); + if (SkiaSharp.ApiOverride.sk_image_new_raster_copy_with_pixmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_raster_copy_with_pixmap_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_raster_data_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_new_raster_data_0_Return(); + var parms = SkiaSharp.sk_image_new_raster_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_raster_data_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_raster_data_0_Pre(parms); + } + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_image_new_raster_data(info, pixels, rowBytes); + var retStruct = new SkiaSharp.sk_image_new_raster_data_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_new_raster_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_raster_data_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_new_raster_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_raster_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_raster_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_raster_0_Pre(parms); + } + var pixmap = parms.pixmap; + var releaseProc = parms.releaseProc; + var context = parms.context; + var ret = CanvasKit._sk_image_new_raster(pixmap, releaseProc, context); + if (SkiaSharp.ApiOverride.sk_image_new_raster_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_raster_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_from_bitmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_from_bitmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_bitmap_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_bitmap_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var ret = CanvasKit._sk_image_new_from_bitmap(cbitmap); + if (SkiaSharp.ApiOverride.sk_image_new_from_bitmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_bitmap_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_from_encoded_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_new_from_encoded_0_Return(); + var parms = SkiaSharp.sk_image_new_from_encoded_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_encoded_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_encoded_0_Pre(parms); + } + var encoded = parms.encoded; + var subset = parms.subset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_image_new_from_encoded(encoded, subset); + var retStruct = new SkiaSharp.sk_image_new_from_encoded_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_new_from_encoded_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_encoded_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_new_from_encoded_1(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_from_encoded_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_encoded_1_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_encoded_1_Pre(parms); + } + var encoded = parms.encoded; + var subsetZero = parms.subsetZero; + var ret = CanvasKit._sk_image_new_from_encoded(encoded, subsetZero); + if (SkiaSharp.ApiOverride.sk_image_new_from_encoded_1_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_encoded_1_Post(ret, parms); + } + return ret; + } + static sk_image_new_from_texture_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_from_texture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_texture_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_texture_0_Pre(parms); + } + var context = parms.context; + var texture = parms.texture; + var origin = parms.origin; + var colorType = parms.colorType; + var alpha = parms.alpha; + var colorSpace = parms.colorSpace; + var releaseProc = parms.releaseProc; + var releaseContext = parms.releaseContext; + var ret = CanvasKit._sk_image_new_from_texture(context, texture, origin, colorType, alpha, colorSpace, releaseProc, releaseContext); + if (SkiaSharp.ApiOverride.sk_image_new_from_texture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_texture_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_from_adopted_texture_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_new_from_adopted_texture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_adopted_texture_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_adopted_texture_0_Pre(parms); + } + var context = parms.context; + var texture = parms.texture; + var origin = parms.origin; + var colorType = parms.colorType; + var alpha = parms.alpha; + var colorSpace = parms.colorSpace; + var ret = CanvasKit._sk_image_new_from_adopted_texture(context, texture, origin, colorType, alpha, colorSpace); + if (SkiaSharp.ApiOverride.sk_image_new_from_adopted_texture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_adopted_texture_0_Post(ret, parms); + } + return ret; + } + static sk_image_new_from_picture_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_new_from_picture_0_Return(); + var parms = SkiaSharp.sk_image_new_from_picture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_picture_0_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_picture_0_Pre(parms); + } + var picture = parms.picture; + var dimensions = parms.dimensions.marshalNew(CanvasKit); + var matrix = parms.matrix.marshalNew(CanvasKit); + var paint = parms.paint; + var ret = CanvasKit._sk_image_new_from_picture(picture, dimensions, matrix, paint); + var retStruct = new SkiaSharp.sk_image_new_from_picture_0_Return(); + retStruct.dimensions = SkiaSharp.SKSizeI.unmarshal(dimensions, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_new_from_picture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_picture_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_new_from_picture_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_new_from_picture_1_Return(); + var parms = SkiaSharp.sk_image_new_from_picture_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_new_from_picture_1_Pre) { + SkiaSharp.ApiOverride.sk_image_new_from_picture_1_Pre(parms); + } + var picture = parms.picture; + var dimensions = parms.dimensions.marshalNew(CanvasKit); + var matrixZero = parms.matrixZero; + var paint = parms.paint; + var ret = CanvasKit._sk_image_new_from_picture(picture, dimensions, matrixZero, paint); + var retStruct = new SkiaSharp.sk_image_new_from_picture_1_Return(); + retStruct.dimensions = SkiaSharp.SKSizeI.unmarshal(dimensions, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_new_from_picture_1_Post) { + ret = SkiaSharp.ApiOverride.sk_image_new_from_picture_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_get_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_width_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_width_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_width(image); + if (SkiaSharp.ApiOverride.sk_image_get_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_width_0_Post(ret, parms); + } + return ret; + } + static sk_image_get_height_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_height_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_height_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_height_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_height(image); + if (SkiaSharp.ApiOverride.sk_image_get_height_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_height_0_Post(ret, parms); + } + return ret; + } + static sk_image_get_unique_id_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_unique_id_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_unique_id_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_unique_id_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_unique_id(image); + if (SkiaSharp.ApiOverride.sk_image_get_unique_id_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_unique_id_0_Post(ret, parms); + } + return ret; + } + static sk_image_get_alpha_type_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_alpha_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_alpha_type_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_alpha_type_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_alpha_type(image); + if (SkiaSharp.ApiOverride.sk_image_get_alpha_type_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_alpha_type_0_Post(ret, parms); + } + return ret; + } + static sk_image_get_color_type_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_color_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_color_type_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_color_type_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_color_type(image); + if (SkiaSharp.ApiOverride.sk_image_get_color_type_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_color_type_0_Post(ret, parms); + } + return ret; + } + static sk_image_get_colorspace_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_get_colorspace_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_get_colorspace_0_Pre) { + SkiaSharp.ApiOverride.sk_image_get_colorspace_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_get_colorspace(image); + if (SkiaSharp.ApiOverride.sk_image_get_colorspace_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_get_colorspace_0_Post(ret, parms); + } + return ret; + } + static sk_image_is_alpha_only_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_is_alpha_only_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_is_alpha_only_0_Pre) { + SkiaSharp.ApiOverride.sk_image_is_alpha_only_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_is_alpha_only(image); + if (SkiaSharp.ApiOverride.sk_image_is_alpha_only_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_is_alpha_only_0_Post(ret, parms); + } + return ret; + } + static sk_image_make_shader_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_make_shader_0_Return(); + var parms = SkiaSharp.sk_image_make_shader_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_make_shader_0_Pre) { + SkiaSharp.ApiOverride.sk_image_make_shader_0_Pre(parms); + } + var image = parms.image; + var tileX = parms.tileX; + var tileY = parms.tileY; + var localMatrix = parms.localMatrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_image_make_shader(image, tileX, tileY, localMatrix); + var retStruct = new SkiaSharp.sk_image_make_shader_0_Return(); + retStruct.localMatrix = SkiaSharp.SKMatrix.unmarshal(localMatrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_make_shader_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_make_shader_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_make_shader_1(pParams, pReturn) { + var parms = SkiaSharp.sk_image_make_shader_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_make_shader_1_Pre) { + SkiaSharp.ApiOverride.sk_image_make_shader_1_Pre(parms); + } + var image = parms.image; + var tileX = parms.tileX; + var tileY = parms.tileY; + var localMatrixZero = parms.localMatrixZero; + var ret = CanvasKit._sk_image_make_shader(image, tileX, tileY, localMatrixZero); + if (SkiaSharp.ApiOverride.sk_image_make_shader_1_Post) { + ret = SkiaSharp.ApiOverride.sk_image_make_shader_1_Post(ret, parms); + } + return ret; + } + static sk_image_peek_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_peek_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_peek_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_image_peek_pixels_0_Pre(parms); + } + var image = parms.image; + var pixmap = parms.pixmap; + var ret = CanvasKit._sk_image_peek_pixels(image, pixmap); + if (SkiaSharp.ApiOverride.sk_image_peek_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_peek_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_image_is_texture_backed_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_is_texture_backed_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_is_texture_backed_0_Pre) { + SkiaSharp.ApiOverride.sk_image_is_texture_backed_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_is_texture_backed(image); + if (SkiaSharp.ApiOverride.sk_image_is_texture_backed_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_is_texture_backed_0_Post(ret, parms); + } + return ret; + } + static sk_image_is_lazy_generated_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_is_lazy_generated_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_is_lazy_generated_0_Pre) { + SkiaSharp.ApiOverride.sk_image_is_lazy_generated_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_is_lazy_generated(image); + if (SkiaSharp.ApiOverride.sk_image_is_lazy_generated_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_is_lazy_generated_0_Post(ret, parms); + } + return ret; + } + static sk_image_read_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_read_pixels_0_Return(); + var parms = SkiaSharp.sk_image_read_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_read_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_image_read_pixels_0_Pre(parms); + } + var image = parms.image; + var dstInfo = parms.dstInfo.marshalNew(CanvasKit); + var dstPixels = parms.dstPixels; + var dstRowBytes = parms.dstRowBytes; + var srcX = parms.srcX; + var srcY = parms.srcY; + var cachingHint = parms.cachingHint; + var ret = CanvasKit._sk_image_read_pixels(image, dstInfo, dstPixels, dstRowBytes, srcX, srcY, cachingHint); + var retStruct = new SkiaSharp.sk_image_read_pixels_0_Return(); + retStruct.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(dstInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_read_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_read_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_read_pixels_into_pixmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_read_pixels_into_pixmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_read_pixels_into_pixmap_0_Pre) { + SkiaSharp.ApiOverride.sk_image_read_pixels_into_pixmap_0_Pre(parms); + } + var image = parms.image; + var dst = parms.dst; + var srcX = parms.srcX; + var srcY = parms.srcY; + var cachingHint = parms.cachingHint; + var ret = CanvasKit._sk_image_read_pixels_into_pixmap(image, dst, srcX, srcY, cachingHint); + if (SkiaSharp.ApiOverride.sk_image_read_pixels_into_pixmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_read_pixels_into_pixmap_0_Post(ret, parms); + } + return ret; + } + static sk_image_scale_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_scale_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_scale_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_image_scale_pixels_0_Pre(parms); + } + var image = parms.image; + var dst = parms.dst; + var quality = parms.quality; + var cachingHint = parms.cachingHint; + var ret = CanvasKit._sk_image_scale_pixels(image, dst, quality, cachingHint); + if (SkiaSharp.ApiOverride.sk_image_scale_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_scale_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_image_ref_encoded_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_ref_encoded_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_ref_encoded_0_Pre) { + SkiaSharp.ApiOverride.sk_image_ref_encoded_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_ref_encoded(image); + if (SkiaSharp.ApiOverride.sk_image_ref_encoded_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_ref_encoded_0_Post(ret, parms); + } + return ret; + } + static sk_image_encode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_encode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_encode_0_Pre) { + SkiaSharp.ApiOverride.sk_image_encode_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_encode(image); + if (SkiaSharp.ApiOverride.sk_image_encode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_encode_0_Post(ret, parms); + } + return ret; + } + static sk_image_encode_specific_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_encode_specific_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_encode_specific_0_Pre) { + SkiaSharp.ApiOverride.sk_image_encode_specific_0_Pre(parms); + } + var image = parms.image; + var encoder = parms.encoder; + var quality = parms.quality; + var ret = CanvasKit._sk_image_encode_specific(image, encoder, quality); + if (SkiaSharp.ApiOverride.sk_image_encode_specific_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_encode_specific_0_Post(ret, parms); + } + return ret; + } + static sk_image_make_subset_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_make_subset_0_Return(); + var parms = SkiaSharp.sk_image_make_subset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_make_subset_0_Pre) { + SkiaSharp.ApiOverride.sk_image_make_subset_0_Pre(parms); + } + var image = parms.image; + var subset = parms.subset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_image_make_subset(image, subset); + var retStruct = new SkiaSharp.sk_image_make_subset_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_make_subset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_make_subset_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_image_make_non_texture_image_0(pParams, pReturn) { + var parms = SkiaSharp.sk_image_make_non_texture_image_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_make_non_texture_image_0_Pre) { + SkiaSharp.ApiOverride.sk_image_make_non_texture_image_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_image_make_non_texture_image(image); + if (SkiaSharp.ApiOverride.sk_image_make_non_texture_image_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_make_non_texture_image_0_Post(ret, parms); + } + return ret; + } + static sk_image_make_with_filter_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_image_make_with_filter_0_Return(); + var parms = SkiaSharp.sk_image_make_with_filter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_image_make_with_filter_0_Pre) { + SkiaSharp.ApiOverride.sk_image_make_with_filter_0_Pre(parms); + } + var image = parms.image; + var filter = parms.filter; + var subset = parms.subset.marshalNew(CanvasKit); + var clipbounds = parms.clipbounds.marshalNew(CanvasKit); + var outSubset = retStruct.outSubset.marshalNew(CanvasKit); + var outOffset = retStruct.outOffset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_image_make_with_filter(image, filter, subset, clipbounds, outSubset, outOffset); + var retStruct = new SkiaSharp.sk_image_make_with_filter_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + retStruct.clipbounds = SkiaSharp.SKRectI.unmarshal(clipbounds, CanvasKit); + retStruct.outSubset = SkiaSharp.SKRectI.unmarshal(outSubset, CanvasKit); + retStruct.outOffset = SkiaSharp.SKPoint.unmarshal(outOffset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_image_make_with_filter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_image_make_with_filter_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_contains_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_contains_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_contains_0_Pre) { + SkiaSharp.ApiOverride.sk_path_contains_0_Pre(parms); + } + var cpath = parms.cpath; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_path_contains(cpath, x, y); + if (SkiaSharp.ApiOverride.sk_path_contains_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_contains_0_Post(ret, parms); + } + return ret; + } + static sk_path_get_last_point_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_get_last_point_0_Return(); + var parms = SkiaSharp.sk_path_get_last_point_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_last_point_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_last_point_0_Pre(parms); + } + var cpath = parms.cpath; + var point = retStruct.point.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_get_last_point(cpath, point); + var retStruct = new SkiaSharp.sk_path_get_last_point_0_Return(); + retStruct.point = SkiaSharp.SKPoint.unmarshal(point, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_get_last_point_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_last_point_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_path_new(); + if (SkiaSharp.ApiOverride.sk_path_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_new_0_Post(ret); + } + return ret; + } + static sk_path_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_path_delete_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_delete(t); + if (SkiaSharp.ApiOverride.sk_path_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_delete_0_Post(ret, parms); + } + return ret; + } + static sk_path_move_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_move_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_move_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_move_to_0_Pre(parms); + } + var t = parms.t; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_path_move_to(t, x, y); + if (SkiaSharp.ApiOverride.sk_path_move_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_move_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rmove_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rmove_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rmove_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rmove_to_0_Pre(parms); + } + var t = parms.t; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_path_rmove_to(t, dx, dy); + if (SkiaSharp.ApiOverride.sk_path_rmove_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rmove_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_line_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_line_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_line_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_line_to_0_Pre(parms); + } + var t = parms.t; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_path_line_to(t, x, y); + if (SkiaSharp.ApiOverride.sk_path_line_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_line_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rline_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rline_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rline_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rline_to_0_Pre(parms); + } + var t = parms.t; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_path_rline_to(t, dx, dy); + if (SkiaSharp.ApiOverride.sk_path_rline_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rline_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_quad_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_quad_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_quad_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_quad_to_0_Pre(parms); + } + var t = parms.t; + var x0 = parms.x0; + var y0 = parms.y0; + var x1 = parms.x1; + var y1 = parms.y1; + var ret = CanvasKit._sk_path_quad_to(t, x0, y0, x1, y1); + if (SkiaSharp.ApiOverride.sk_path_quad_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_quad_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rquad_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rquad_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rquad_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rquad_to_0_Pre(parms); + } + var t = parms.t; + var dx0 = parms.dx0; + var dy0 = parms.dy0; + var dx1 = parms.dx1; + var dy1 = parms.dy1; + var ret = CanvasKit._sk_path_rquad_to(t, dx0, dy0, dx1, dy1); + if (SkiaSharp.ApiOverride.sk_path_rquad_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rquad_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_conic_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_conic_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_conic_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_conic_to_0_Pre(parms); + } + var t = parms.t; + var x0 = parms.x0; + var y0 = parms.y0; + var x1 = parms.x1; + var y1 = parms.y1; + var w = parms.w; + var ret = CanvasKit._sk_path_conic_to(t, x0, y0, x1, y1, w); + if (SkiaSharp.ApiOverride.sk_path_conic_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_conic_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rconic_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rconic_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rconic_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rconic_to_0_Pre(parms); + } + var t = parms.t; + var dx0 = parms.dx0; + var dy0 = parms.dy0; + var dx1 = parms.dx1; + var dy1 = parms.dy1; + var w = parms.w; + var ret = CanvasKit._sk_path_rconic_to(t, dx0, dy0, dx1, dy1, w); + if (SkiaSharp.ApiOverride.sk_path_rconic_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rconic_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_cubic_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_cubic_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_cubic_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_cubic_to_0_Pre(parms); + } + var t = parms.t; + var x0 = parms.x0; + var y0 = parms.y0; + var x1 = parms.x1; + var y1 = parms.y1; + var x2 = parms.x2; + var y2 = parms.y2; + var ret = CanvasKit._sk_path_cubic_to(t, x0, y0, x1, y1, x2, y2); + if (SkiaSharp.ApiOverride.sk_path_cubic_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_cubic_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rcubic_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rcubic_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rcubic_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rcubic_to_0_Pre(parms); + } + var t = parms.t; + var dx0 = parms.dx0; + var dy0 = parms.dy0; + var dx1 = parms.dx1; + var dy1 = parms.dy1; + var dx2 = parms.dx2; + var dy2 = parms.dy2; + var ret = CanvasKit._sk_path_rcubic_to(t, dx0, dy0, dx1, dy1, dx2, dy2); + if (SkiaSharp.ApiOverride.sk_path_rcubic_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rcubic_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_close_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_close_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_close_0_Pre) { + SkiaSharp.ApiOverride.sk_path_close_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_close(t); + if (SkiaSharp.ApiOverride.sk_path_close_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_close_0_Post(ret, parms); + } + return ret; + } + static sk_path_rewind_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rewind_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rewind_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rewind_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_rewind(t); + if (SkiaSharp.ApiOverride.sk_path_rewind_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rewind_0_Post(ret, parms); + } + return ret; + } + static sk_path_reset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_reset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_reset_0_Pre) { + SkiaSharp.ApiOverride.sk_path_reset_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_reset(t); + if (SkiaSharp.ApiOverride.sk_path_reset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_reset_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_rect_0_Return(); + var parms = SkiaSharp.sk_path_add_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_rect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var direction = parms.direction; + var ret = CanvasKit._sk_path_add_rect(t, rect, direction); + var retStruct = new SkiaSharp.sk_path_add_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_rect_start_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_rect_start_0_Return(); + var parms = SkiaSharp.sk_path_add_rect_start_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_rect_start_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_rect_start_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var direction = parms.direction; + var startIndex = parms.startIndex; + var ret = CanvasKit._sk_path_add_rect_start(t, rect, direction, startIndex); + var retStruct = new SkiaSharp.sk_path_add_rect_start_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_rect_start_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_rect_start_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_rrect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_rrect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_rrect_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_rrect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect; + var direction = parms.direction; + var ret = CanvasKit._sk_path_add_rrect(t, rect, direction); + if (SkiaSharp.ApiOverride.sk_path_add_rrect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_rrect_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_rrect_start_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_rrect_start_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_rrect_start_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_rrect_start_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect; + var direction = parms.direction; + var startIndex = parms.startIndex; + var ret = CanvasKit._sk_path_add_rrect_start(t, rect, direction, startIndex); + if (SkiaSharp.ApiOverride.sk_path_add_rrect_start_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_rrect_start_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_oval_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_oval_0_Return(); + var parms = SkiaSharp.sk_path_add_oval_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_oval_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_oval_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var direction = parms.direction; + var ret = CanvasKit._sk_path_add_oval(t, rect, direction); + var retStruct = new SkiaSharp.sk_path_add_oval_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_oval_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_oval_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_arc_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_arc_0_Return(); + var parms = SkiaSharp.sk_path_add_arc_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_arc_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_arc_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var startAngle = parms.startAngle; + var sweepAngle = parms.sweepAngle; + var ret = CanvasKit._sk_path_add_arc(t, rect, startAngle, sweepAngle); + var retStruct = new SkiaSharp.sk_path_add_arc_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_arc_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_arc_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_path_offset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_path_offset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_path_offset_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_path_offset_0_Pre(parms); + } + var t = parms.t; + var other = parms.other; + var dx = parms.dx; + var dy = parms.dy; + var mode = parms.mode; + var ret = CanvasKit._sk_path_add_path_offset(t, other, dx, dy, mode); + if (SkiaSharp.ApiOverride.sk_path_add_path_offset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_path_offset_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_path_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_path_matrix_0_Return(); + var parms = SkiaSharp.sk_path_add_path_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_path_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_path_matrix_0_Pre(parms); + } + var t = parms.t; + var other = parms.other; + var matrix = parms.matrix.marshalNew(CanvasKit); + var mode = parms.mode; + var ret = CanvasKit._sk_path_add_path_matrix(t, other, matrix, mode); + var retStruct = new SkiaSharp.sk_path_add_path_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_path_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_path_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_path_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_path_0_Pre(parms); + } + var t = parms.t; + var other = parms.other; + var mode = parms.mode; + var ret = CanvasKit._sk_path_add_path(t, other, mode); + if (SkiaSharp.ApiOverride.sk_path_add_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_path_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_path_reverse_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_path_reverse_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_path_reverse_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_path_reverse_0_Pre(parms); + } + var t = parms.t; + var other = parms.other; + var ret = CanvasKit._sk_path_add_path_reverse(t, other); + if (SkiaSharp.ApiOverride.sk_path_add_path_reverse_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_path_reverse_0_Post(ret, parms); + } + return ret; + } + static sk_path_get_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_get_bounds_0_Return(); + var parms = SkiaSharp.sk_path_get_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_bounds_0_Pre(parms); + } + var t = parms.t; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_get_bounds(t, rect); + var retStruct = new SkiaSharp.sk_path_get_bounds_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_get_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_compute_tight_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_compute_tight_bounds_0_Return(); + var parms = SkiaSharp.sk_path_compute_tight_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_compute_tight_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_path_compute_tight_bounds_0_Pre(parms); + } + var t = parms.t; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_compute_tight_bounds(t, rect); + var retStruct = new SkiaSharp.sk_path_compute_tight_bounds_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_compute_tight_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_compute_tight_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_get_filltype_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_get_filltype_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_filltype_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_filltype_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_get_filltype(t); + if (SkiaSharp.ApiOverride.sk_path_get_filltype_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_filltype_0_Post(ret, parms); + } + return ret; + } + static sk_path_set_filltype_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_set_filltype_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_set_filltype_0_Pre) { + SkiaSharp.ApiOverride.sk_path_set_filltype_0_Pre(parms); + } + var t = parms.t; + var filltype = parms.filltype; + var ret = CanvasKit._sk_path_set_filltype(t, filltype); + if (SkiaSharp.ApiOverride.sk_path_set_filltype_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_set_filltype_0_Post(ret, parms); + } + return ret; + } + static sk_path_clone_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_clone_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_clone_0_Pre) { + SkiaSharp.ApiOverride.sk_path_clone_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_clone(t); + if (SkiaSharp.ApiOverride.sk_path_clone_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_clone_0_Post(ret, parms); + } + return ret; + } + static sk_path_transform_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_transform_0_Return(); + var parms = SkiaSharp.sk_path_transform_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_transform_0_Pre) { + SkiaSharp.ApiOverride.sk_path_transform_0_Pre(parms); + } + var t = parms.t; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_transform(t, matrix); + var retStruct = new SkiaSharp.sk_path_transform_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_transform_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_transform_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_arc_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_arc_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_arc_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_arc_to_0_Pre(parms); + } + var t = parms.t; + var rx = parms.rx; + var ry = parms.ry; + var xAxisRotate = parms.xAxisRotate; + var largeArc = parms.largeArc; + var sweep = parms.sweep; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_path_arc_to(t, rx, ry, xAxisRotate, largeArc, sweep, x, y); + if (SkiaSharp.ApiOverride.sk_path_arc_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_arc_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_rarc_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rarc_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rarc_to_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rarc_to_0_Pre(parms); + } + var t = parms.t; + var rx = parms.rx; + var ry = parms.ry; + var xAxisRotate = parms.xAxisRotate; + var largeArc = parms.largeArc; + var sweep = parms.sweep; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_path_rarc_to(t, rx, ry, xAxisRotate, largeArc, sweep, x, y); + if (SkiaSharp.ApiOverride.sk_path_rarc_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rarc_to_0_Post(ret, parms); + } + return ret; + } + static sk_path_arc_to_with_oval_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_arc_to_with_oval_0_Return(); + var parms = SkiaSharp.sk_path_arc_to_with_oval_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_arc_to_with_oval_0_Pre) { + SkiaSharp.ApiOverride.sk_path_arc_to_with_oval_0_Pre(parms); + } + var t = parms.t; + var oval = parms.oval.marshalNew(CanvasKit); + var startAngle = parms.startAngle; + var sweepAngle = parms.sweepAngle; + var forceMoveTo = parms.forceMoveTo; + var ret = CanvasKit._sk_path_arc_to_with_oval(t, oval, startAngle, sweepAngle, forceMoveTo); + var retStruct = new SkiaSharp.sk_path_arc_to_with_oval_0_Return(); + retStruct.oval = SkiaSharp.SKRect.unmarshal(oval, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_arc_to_with_oval_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_arc_to_with_oval_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_arc_to_with_points_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_arc_to_with_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_arc_to_with_points_0_Pre) { + SkiaSharp.ApiOverride.sk_path_arc_to_with_points_0_Pre(parms); + } + var t = parms.t; + var x1 = parms.x1; + var y1 = parms.y1; + var x2 = parms.x2; + var y2 = parms.y2; + var radius = parms.radius; + var ret = CanvasKit._sk_path_arc_to_with_points(t, x1, y1, x2, y2, radius); + if (SkiaSharp.ApiOverride.sk_path_arc_to_with_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_arc_to_with_points_0_Post(ret, parms); + } + return ret; + } + static sk_path_add_rounded_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_add_rounded_rect_0_Return(); + var parms = SkiaSharp.sk_path_add_rounded_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_rounded_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_rounded_rect_0_Pre(parms); + } + var t = parms.t; + var rect = parms.rect.marshalNew(CanvasKit); + var rx = parms.rx; + var ry = parms.ry; + var dir = parms.dir; + var ret = CanvasKit._sk_path_add_rounded_rect(t, rect, rx, ry, dir); + var retStruct = new SkiaSharp.sk_path_add_rounded_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_add_rounded_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_rounded_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_circle_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_circle_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_circle_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_circle_0_Pre(parms); + } + var t = parms.t; + var x = parms.x; + var y = parms.y; + var radius = parms.radius; + var dir = parms.dir; + var ret = CanvasKit._sk_path_add_circle(t, x, y, radius, dir); + if (SkiaSharp.ApiOverride.sk_path_add_circle_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_circle_0_Post(ret, parms); + } + return ret; + } + static sk_path_count_verbs_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_count_verbs_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_count_verbs_0_Pre) { + SkiaSharp.ApiOverride.sk_path_count_verbs_0_Pre(parms); + } + var path = parms.path; + var ret = CanvasKit._sk_path_count_verbs(path); + if (SkiaSharp.ApiOverride.sk_path_count_verbs_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_count_verbs_0_Post(ret, parms); + } + return ret; + } + static sk_path_count_points_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_count_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_count_points_0_Pre) { + SkiaSharp.ApiOverride.sk_path_count_points_0_Pre(parms); + } + var path = parms.path; + var ret = CanvasKit._sk_path_count_points(path); + if (SkiaSharp.ApiOverride.sk_path_count_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_count_points_0_Post(ret, parms); + } + return ret; + } + static sk_path_get_point_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_get_point_0_Return(); + var parms = SkiaSharp.sk_path_get_point_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_point_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_point_0_Pre(parms); + } + var path = parms.path; + var index = parms.index; + var point = retStruct.point.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_get_point(path, index, point); + var retStruct = new SkiaSharp.sk_path_get_point_0_Return(); + retStruct.point = SkiaSharp.SKPoint.unmarshal(point, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_get_point_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_point_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_get_points_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_get_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_points_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_points_0_Pre(parms); + } + var path = parms.path; + var points = parms.points; + var max = parms.max; + var ret = CanvasKit._sk_path_get_points(path, points, max); + if (SkiaSharp.ApiOverride.sk_path_get_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_points_0_Post(ret, parms); + } + return ret; + } + static sk_path_get_convexity_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_get_convexity_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_convexity_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_convexity_0_Pre(parms); + } + var cpath = parms.cpath; + var ret = CanvasKit._sk_path_get_convexity(cpath); + if (SkiaSharp.ApiOverride.sk_path_get_convexity_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_convexity_0_Post(ret, parms); + } + return ret; + } + static sk_path_set_convexity_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_set_convexity_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_set_convexity_0_Pre) { + SkiaSharp.ApiOverride.sk_path_set_convexity_0_Pre(parms); + } + var cpath = parms.cpath; + var convexity = parms.convexity; + var ret = CanvasKit._sk_path_set_convexity(cpath, convexity); + if (SkiaSharp.ApiOverride.sk_path_set_convexity_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_set_convexity_0_Post(ret, parms); + } + return ret; + } + static sk_path_parse_svg_string_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_parse_svg_string_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_parse_svg_string_0_Pre) { + SkiaSharp.ApiOverride.sk_path_parse_svg_string_0_Pre(parms); + } + var cpath = parms.cpath; + var str_Length = parms.str.length * 4 + 1; + var str = CanvasKit._malloc(str_Length); + CanvasKit.stringToUTF8(parms.str, str, str_Length); + var ret = CanvasKit._sk_path_parse_svg_string(cpath, str); + if (SkiaSharp.ApiOverride.sk_path_parse_svg_string_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_parse_svg_string_0_Post(ret, parms); + } + return ret; + } + static sk_path_to_svg_string_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_to_svg_string_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_to_svg_string_0_Pre) { + SkiaSharp.ApiOverride.sk_path_to_svg_string_0_Pre(parms); + } + var cpath = parms.cpath; + var str = parms.str; + var ret = CanvasKit._sk_path_to_svg_string(cpath, str); + if (SkiaSharp.ApiOverride.sk_path_to_svg_string_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_to_svg_string_0_Post(ret, parms); + } + return ret; + } + static sk_path_convert_conic_to_quads_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_convert_conic_to_quads_0_Return(); + var parms = SkiaSharp.sk_path_convert_conic_to_quads_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_convert_conic_to_quads_0_Pre) { + SkiaSharp.ApiOverride.sk_path_convert_conic_to_quads_0_Pre(parms); + } + var p0 = parms.p0.marshalNew(CanvasKit); + var p1 = parms.p1.marshalNew(CanvasKit); + var p2 = parms.p2.marshalNew(CanvasKit); + var w = parms.w; + var pts = parms.pts; + var pow2 = parms.pow2; + var ret = CanvasKit._sk_path_convert_conic_to_quads(p0, p1, p2, w, pts, pow2); + var retStruct = new SkiaSharp.sk_path_convert_conic_to_quads_0_Return(); + retStruct.p0 = SkiaSharp.SKPoint.unmarshal(p0, CanvasKit); + retStruct.p1 = SkiaSharp.SKPoint.unmarshal(p1, CanvasKit); + retStruct.p2 = SkiaSharp.SKPoint.unmarshal(p2, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_convert_conic_to_quads_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_convert_conic_to_quads_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_add_poly_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_add_poly_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_add_poly_0_Pre) { + SkiaSharp.ApiOverride.sk_path_add_poly_0_Pre(parms); + } + var cpath = parms.cpath; + var points = parms.points; + var count = parms.count; + var close = parms.close; + var ret = CanvasKit._sk_path_add_poly(cpath, points, count, close); + if (SkiaSharp.ApiOverride.sk_path_add_poly_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_add_poly_0_Post(ret, parms); + } + return ret; + } + static sk_path_get_segment_masks_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_get_segment_masks_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_get_segment_masks_0_Pre) { + SkiaSharp.ApiOverride.sk_path_get_segment_masks_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_path_get_segment_masks(t); + if (SkiaSharp.ApiOverride.sk_path_get_segment_masks_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_get_segment_masks_0_Post(ret, parms); + } + return ret; + } + static sk_path_is_oval_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_is_oval_0_Return(); + var parms = SkiaSharp.sk_path_is_oval_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_oval_0_Pre) { + SkiaSharp.ApiOverride.sk_path_is_oval_0_Pre(parms); + } + var cpath = parms.cpath; + var bounds = retStruct.bounds.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_is_oval(cpath, bounds); + var retStruct = new SkiaSharp.sk_path_is_oval_0_Return(); + retStruct.bounds = SkiaSharp.SKRect.unmarshal(bounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_is_oval_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_oval_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_is_oval_1(pParams, pReturn) { + var parms = SkiaSharp.sk_path_is_oval_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_oval_1_Pre) { + SkiaSharp.ApiOverride.sk_path_is_oval_1_Pre(parms); + } + var cpath = parms.cpath; + var boundsZero = parms.boundsZero; + var ret = CanvasKit._sk_path_is_oval(cpath, boundsZero); + if (SkiaSharp.ApiOverride.sk_path_is_oval_1_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_oval_1_Post(ret, parms); + } + return ret; + } + static sk_path_is_rrect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_is_rrect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_rrect_0_Pre) { + SkiaSharp.ApiOverride.sk_path_is_rrect_0_Pre(parms); + } + var cpath = parms.cpath; + var bounds = parms.bounds; + var ret = CanvasKit._sk_path_is_rrect(cpath, bounds); + if (SkiaSharp.ApiOverride.sk_path_is_rrect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_rrect_0_Post(ret, parms); + } + return ret; + } + static sk_path_is_line_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_is_line_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_line_0_Pre) { + SkiaSharp.ApiOverride.sk_path_is_line_0_Pre(parms); + } + var cpath = parms.cpath; + var line = parms.line; + var ret = CanvasKit._sk_path_is_line(cpath, line); + if (SkiaSharp.ApiOverride.sk_path_is_line_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_line_0_Post(ret, parms); + } + return ret; + } + static sk_path_is_line_1(pParams, pReturn) { + var parms = SkiaSharp.sk_path_is_line_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_line_1_Pre) { + SkiaSharp.ApiOverride.sk_path_is_line_1_Pre(parms); + } + var cpath = parms.cpath; + var lineZero = parms.lineZero; + var ret = CanvasKit._sk_path_is_line(cpath, lineZero); + if (SkiaSharp.ApiOverride.sk_path_is_line_1_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_line_1_Post(ret, parms); + } + return ret; + } + static sk_path_is_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_is_rect_0_Return(); + var parms = SkiaSharp.sk_path_is_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_path_is_rect_0_Pre(parms); + } + var cpath = parms.cpath; + var rect = retStruct.rect.marshalNew(CanvasKit); + var isClosed = CanvasKit._malloc(4); + var direction = CanvasKit._malloc(4); + var ret = CanvasKit._sk_path_is_rect(cpath, rect, isClosed, direction); + var retStruct = new SkiaSharp.sk_path_is_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + retStruct.isClosed = CanvasKit.getValue(isClosed, "i32"); + retStruct.direction = CanvasKit.getValue(direction, "i32"); + if (SkiaSharp.ApiOverride.sk_path_is_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_is_rect_1(pParams, pReturn) { + var parms = SkiaSharp.sk_path_is_rect_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_is_rect_1_Pre) { + SkiaSharp.ApiOverride.sk_path_is_rect_1_Pre(parms); + } + var cpath = parms.cpath; + var rectZero = parms.rectZero; + var isClosedZero = parms.isClosedZero; + var directionZero = parms.directionZero; + var ret = CanvasKit._sk_path_is_rect(cpath, rectZero, isClosedZero, directionZero); + if (SkiaSharp.ApiOverride.sk_path_is_rect_1_Post) { + ret = SkiaSharp.ApiOverride.sk_path_is_rect_1_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_pathmeasure_new(); + if (SkiaSharp.ApiOverride.sk_pathmeasure_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_new_0_Post(ret); + } + return ret; + } + static sk_pathmeasure_new_with_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_new_with_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_new_with_path_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_new_with_path_0_Pre(parms); + } + var path = parms.path; + var forceClosed = parms.forceClosed; + var resScale = parms.resScale; + var ret = CanvasKit._sk_pathmeasure_new_with_path(path, forceClosed, resScale); + if (SkiaSharp.ApiOverride.sk_pathmeasure_new_with_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_new_with_path_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_destroy_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var ret = CanvasKit._sk_pathmeasure_destroy(pathMeasure); + if (SkiaSharp.ApiOverride.sk_pathmeasure_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_set_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_set_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_set_path_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_set_path_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var path = parms.path; + var forceClosed = parms.forceClosed; + var ret = CanvasKit._sk_pathmeasure_set_path(pathMeasure, path, forceClosed); + if (SkiaSharp.ApiOverride.sk_pathmeasure_set_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_set_path_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_get_length_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_get_length_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_length_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_length_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var ret = CanvasKit._sk_pathmeasure_get_length(pathMeasure); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_length_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_length_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_get_pos_tan_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_0_Return(); + var parms = SkiaSharp.sk_pathmeasure_get_pos_tan_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var distance = parms.distance; + var position = retStruct.position.marshalNew(CanvasKit); + var tangent = retStruct.tangent.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pathmeasure_get_pos_tan(pathMeasure, distance, position, tangent); + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_0_Return(); + retStruct.position = SkiaSharp.SKPoint.unmarshal(position, CanvasKit); + retStruct.tangent = SkiaSharp.SKPoint.unmarshal(tangent, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pathmeasure_get_pos_tan_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_1_Return(); + var parms = SkiaSharp.sk_pathmeasure_get_pos_tan_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_1_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_1_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var distance = parms.distance; + var positionZero = parms.positionZero; + var tangent = retStruct.tangent.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pathmeasure_get_pos_tan(pathMeasure, distance, positionZero, tangent); + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_1_Return(); + retStruct.tangent = SkiaSharp.SKPoint.unmarshal(tangent, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_1_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pathmeasure_get_pos_tan_2(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_2_Return(); + var parms = SkiaSharp.sk_pathmeasure_get_pos_tan_2_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_2_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_2_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var distance = parms.distance; + var position = retStruct.position.marshalNew(CanvasKit); + var tangentZero = parms.tangentZero; + var ret = CanvasKit._sk_pathmeasure_get_pos_tan(pathMeasure, distance, position, tangentZero); + var retStruct = new SkiaSharp.sk_pathmeasure_get_pos_tan_2_Return(); + retStruct.position = SkiaSharp.SKPoint.unmarshal(position, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_2_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_pos_tan_2_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pathmeasure_get_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pathmeasure_get_matrix_0_Return(); + var parms = SkiaSharp.sk_pathmeasure_get_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_matrix_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var distance = parms.distance; + var matrix = retStruct.matrix.marshalNew(CanvasKit); + var flags = parms.flags; + var ret = CanvasKit._sk_pathmeasure_get_matrix(pathMeasure, distance, matrix, flags); + var retStruct = new SkiaSharp.sk_pathmeasure_get_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pathmeasure_get_segment_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_get_segment_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_segment_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_get_segment_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var start = parms.start; + var stop = parms.stop; + var dst = parms.dst; + var startWithMoveTo = parms.startWithMoveTo; + var ret = CanvasKit._sk_pathmeasure_get_segment(pathMeasure, start, stop, dst, startWithMoveTo); + if (SkiaSharp.ApiOverride.sk_pathmeasure_get_segment_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_get_segment_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_is_closed_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_is_closed_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_is_closed_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_is_closed_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var ret = CanvasKit._sk_pathmeasure_is_closed(pathMeasure); + if (SkiaSharp.ApiOverride.sk_pathmeasure_is_closed_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_is_closed_0_Post(ret, parms); + } + return ret; + } + static sk_pathmeasure_next_contour_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathmeasure_next_contour_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathmeasure_next_contour_0_Pre) { + SkiaSharp.ApiOverride.sk_pathmeasure_next_contour_0_Pre(parms); + } + var pathMeasure = parms.pathMeasure; + var ret = CanvasKit._sk_pathmeasure_next_contour(pathMeasure); + if (SkiaSharp.ApiOverride.sk_pathmeasure_next_contour_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathmeasure_next_contour_0_Post(ret, parms); + } + return ret; + } + static sk_pathop_op_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathop_op_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathop_op_0_Pre) { + SkiaSharp.ApiOverride.sk_pathop_op_0_Pre(parms); + } + var one = parms.one; + var two = parms.two; + var op = parms.op; + var result = parms.result; + var ret = CanvasKit._sk_pathop_op(one, two, op, result); + if (SkiaSharp.ApiOverride.sk_pathop_op_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathop_op_0_Post(ret, parms); + } + return ret; + } + static sk_pathop_simplify_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pathop_simplify_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathop_simplify_0_Pre) { + SkiaSharp.ApiOverride.sk_pathop_simplify_0_Pre(parms); + } + var path = parms.path; + var result = parms.result; + var ret = CanvasKit._sk_pathop_simplify(path, result); + if (SkiaSharp.ApiOverride.sk_pathop_simplify_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathop_simplify_0_Post(ret, parms); + } + return ret; + } + static sk_pathop_tight_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pathop_tight_bounds_0_Return(); + var parms = SkiaSharp.sk_pathop_tight_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pathop_tight_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_pathop_tight_bounds_0_Pre(parms); + } + var path = parms.path; + var result = retStruct.result.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pathop_tight_bounds(path, result); + var retStruct = new SkiaSharp.sk_pathop_tight_bounds_0_Return(); + retStruct.result = SkiaSharp.SKRect.unmarshal(result, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pathop_tight_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pathop_tight_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_opbuilder_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_opbuilder_new(); + if (SkiaSharp.ApiOverride.sk_opbuilder_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_opbuilder_new_0_Post(ret); + } + return ret; + } + static sk_opbuilder_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_opbuilder_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_opbuilder_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_opbuilder_destroy_0_Pre(parms); + } + var builder = parms.builder; + var ret = CanvasKit._sk_opbuilder_destroy(builder); + if (SkiaSharp.ApiOverride.sk_opbuilder_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_opbuilder_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_opbuilder_add_0(pParams, pReturn) { + var parms = SkiaSharp.sk_opbuilder_add_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_opbuilder_add_0_Pre) { + SkiaSharp.ApiOverride.sk_opbuilder_add_0_Pre(parms); + } + var builder = parms.builder; + var path = parms.path; + var op = parms.op; + var ret = CanvasKit._sk_opbuilder_add(builder, path, op); + if (SkiaSharp.ApiOverride.sk_opbuilder_add_0_Post) { + ret = SkiaSharp.ApiOverride.sk_opbuilder_add_0_Post(ret, parms); + } + return ret; + } + static sk_opbuilder_resolve_0(pParams, pReturn) { + var parms = SkiaSharp.sk_opbuilder_resolve_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_opbuilder_resolve_0_Pre) { + SkiaSharp.ApiOverride.sk_opbuilder_resolve_0_Pre(parms); + } + var builder = parms.builder; + var result = parms.result; + var ret = CanvasKit._sk_opbuilder_resolve(builder, result); + if (SkiaSharp.ApiOverride.sk_opbuilder_resolve_0_Post) { + ret = SkiaSharp.ApiOverride.sk_opbuilder_resolve_0_Post(ret, parms); + } + return ret; + } + static sk_path_create_iter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_create_iter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_create_iter_0_Pre) { + SkiaSharp.ApiOverride.sk_path_create_iter_0_Pre(parms); + } + var path = parms.path; + var forceClose = parms.forceClose; + var ret = CanvasKit._sk_path_create_iter(path, forceClose); + if (SkiaSharp.ApiOverride.sk_path_create_iter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_create_iter_0_Post(ret, parms); + } + return ret; + } + static sk_path_iter_next_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_iter_next_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_iter_next_0_Pre) { + SkiaSharp.ApiOverride.sk_path_iter_next_0_Pre(parms); + } + var iterator = parms.iterator; + var points = parms.points; + var doConsumeDegenerates = parms.doConsumeDegenerates; + var exact = parms.exact; + var ret = CanvasKit._sk_path_iter_next(iterator, points, doConsumeDegenerates, exact); + if (SkiaSharp.ApiOverride.sk_path_iter_next_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_iter_next_0_Post(ret, parms); + } + return ret; + } + static sk_path_iter_conic_weight_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_iter_conic_weight_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_iter_conic_weight_0_Pre) { + SkiaSharp.ApiOverride.sk_path_iter_conic_weight_0_Pre(parms); + } + var iterator = parms.iterator; + var ret = CanvasKit._sk_path_iter_conic_weight(iterator); + if (SkiaSharp.ApiOverride.sk_path_iter_conic_weight_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_iter_conic_weight_0_Post(ret, parms); + } + return ret; + } + static sk_path_iter_is_close_line_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_iter_is_close_line_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_iter_is_close_line_0_Pre) { + SkiaSharp.ApiOverride.sk_path_iter_is_close_line_0_Pre(parms); + } + var iterator = parms.iterator; + var ret = CanvasKit._sk_path_iter_is_close_line(iterator); + if (SkiaSharp.ApiOverride.sk_path_iter_is_close_line_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_iter_is_close_line_0_Post(ret, parms); + } + return ret; + } + static sk_path_iter_is_closed_contour_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_iter_is_closed_contour_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_iter_is_closed_contour_0_Pre) { + SkiaSharp.ApiOverride.sk_path_iter_is_closed_contour_0_Pre(parms); + } + var iterator = parms.iterator; + var ret = CanvasKit._sk_path_iter_is_closed_contour(iterator); + if (SkiaSharp.ApiOverride.sk_path_iter_is_closed_contour_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_iter_is_closed_contour_0_Post(ret, parms); + } + return ret; + } + static sk_path_iter_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_iter_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_iter_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_path_iter_destroy_0_Pre(parms); + } + var path = parms.path; + var ret = CanvasKit._sk_path_iter_destroy(path); + if (SkiaSharp.ApiOverride.sk_path_iter_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_iter_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_path_create_rawiter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_create_rawiter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_create_rawiter_0_Pre) { + SkiaSharp.ApiOverride.sk_path_create_rawiter_0_Pre(parms); + } + var path = parms.path; + var ret = CanvasKit._sk_path_create_rawiter(path); + if (SkiaSharp.ApiOverride.sk_path_create_rawiter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_create_rawiter_0_Post(ret, parms); + } + return ret; + } + static sk_path_rawiter_next_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rawiter_next_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rawiter_next_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rawiter_next_0_Pre(parms); + } + var iterator = parms.iterator; + var points = parms.points; + var ret = CanvasKit._sk_path_rawiter_next(iterator, points); + if (SkiaSharp.ApiOverride.sk_path_rawiter_next_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rawiter_next_0_Post(ret, parms); + } + return ret; + } + static sk_path_rawiter_peek_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rawiter_peek_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rawiter_peek_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rawiter_peek_0_Pre(parms); + } + var iterator = parms.iterator; + var ret = CanvasKit._sk_path_rawiter_peek(iterator); + if (SkiaSharp.ApiOverride.sk_path_rawiter_peek_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rawiter_peek_0_Post(ret, parms); + } + return ret; + } + static sk_path_rawiter_conic_weight_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rawiter_conic_weight_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rawiter_conic_weight_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rawiter_conic_weight_0_Pre(parms); + } + var iterator = parms.iterator; + var ret = CanvasKit._sk_path_rawiter_conic_weight(iterator); + if (SkiaSharp.ApiOverride.sk_path_rawiter_conic_weight_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rawiter_conic_weight_0_Post(ret, parms); + } + return ret; + } + static sk_path_rawiter_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_rawiter_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_rawiter_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_path_rawiter_destroy_0_Pre(parms); + } + var path = parms.path; + var ret = CanvasKit._sk_path_rawiter_destroy(path); + if (SkiaSharp.ApiOverride.sk_path_rawiter_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_rawiter_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_maskfilter_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_maskfilter_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_unref_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_maskfilter_unref(t); + if (SkiaSharp.ApiOverride.sk_maskfilter_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_unref_0_Post(ret, parms); + } + return ret; + } + static sk_maskfilter_new_blur_0(pParams, pReturn) { + var parms = SkiaSharp.sk_maskfilter_new_blur_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_blur_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_new_blur_0_Pre(parms); + } + var style = parms.style; + var sigma = parms.sigma; + var ret = CanvasKit._sk_maskfilter_new_blur(style, sigma); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_blur_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_new_blur_0_Post(ret, parms); + } + return ret; + } + static sk_maskfilter_new_blur_with_flags_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_maskfilter_new_blur_with_flags_0_Return(); + var parms = SkiaSharp.sk_maskfilter_new_blur_with_flags_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_blur_with_flags_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_new_blur_with_flags_0_Pre(parms); + } + var style = parms.style; + var sigma = parms.sigma; + var occluder = parms.occluder.marshalNew(CanvasKit); + var respectCTM = parms.respectCTM; + var ret = CanvasKit._sk_maskfilter_new_blur_with_flags(style, sigma, occluder, respectCTM); + var retStruct = new SkiaSharp.sk_maskfilter_new_blur_with_flags_0_Return(); + retStruct.occluder = SkiaSharp.SKRect.unmarshal(occluder, CanvasKit); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_blur_with_flags_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_new_blur_with_flags_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_maskfilter_new_table_0(pParams, pReturn) { + var parms = SkiaSharp.sk_maskfilter_new_table_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_table_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_new_table_0_Pre(parms); + } + var table = CanvasKit._malloc(parms.table_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.table_Length; i++) { + CanvasKit.HEAPU8[table + i] = parms.table[i]; + } + } + var ret = CanvasKit._sk_maskfilter_new_table(table); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_table_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_new_table_0_Post(ret, parms); + } + return ret; + } + static sk_maskfilter_new_gamma_0(pParams, pReturn) { + var parms = SkiaSharp.sk_maskfilter_new_gamma_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_gamma_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_new_gamma_0_Pre(parms); + } + var gamma = parms.gamma; + var ret = CanvasKit._sk_maskfilter_new_gamma(gamma); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_gamma_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_new_gamma_0_Post(ret, parms); + } + return ret; + } + static sk_maskfilter_new_clip_0(pParams, pReturn) { + var parms = SkiaSharp.sk_maskfilter_new_clip_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_clip_0_Pre) { + SkiaSharp.ApiOverride.sk_maskfilter_new_clip_0_Pre(parms); + } + var min = parms.min; + var max = parms.max; + var ret = CanvasKit._sk_maskfilter_new_clip(min, max); + if (SkiaSharp.ApiOverride.sk_maskfilter_new_clip_0_Post) { + ret = SkiaSharp.ApiOverride.sk_maskfilter_new_clip_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_croprect_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_imagefilter_croprect_new(); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_0_Post(ret); + } + return ret; + } + static sk_imagefilter_croprect_new_with_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_croprect_new_with_rect_0_Return(); + var parms = SkiaSharp.sk_imagefilter_croprect_new_with_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_with_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_with_rect_0_Pre(parms); + } + var rect = parms.rect.marshalNew(CanvasKit); + var flags = parms.flags; + var ret = CanvasKit._sk_imagefilter_croprect_new_with_rect(rect, flags); + var retStruct = new SkiaSharp.sk_imagefilter_croprect_new_with_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_with_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_croprect_new_with_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_croprect_destructor_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_croprect_destructor_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_destructor_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_croprect_destructor_0_Pre(parms); + } + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_croprect_destructor(cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_destructor_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_croprect_destructor_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_croprect_get_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_croprect_get_rect_0_Return(); + var parms = SkiaSharp.sk_imagefilter_croprect_get_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_rect_0_Pre(parms); + } + var cropRect = parms.cropRect; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_imagefilter_croprect_get_rect(cropRect, rect); + var retStruct = new SkiaSharp.sk_imagefilter_croprect_get_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_croprect_get_flags_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_croprect_get_flags_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_flags_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_flags_0_Pre(parms); + } + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_croprect_get_flags(cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_flags_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_croprect_get_flags_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_unref_0_Pre(parms); + } + var filter = parms.filter; + var ret = CanvasKit._sk_imagefilter_unref(filter); + if (SkiaSharp.ApiOverride.sk_imagefilter_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_unref_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_matrix_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var quality = parms.quality; + var input = parms.input; + var ret = CanvasKit._sk_imagefilter_new_matrix(matrix, quality, input); + var retStruct = new SkiaSharp.sk_imagefilter_new_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_alpha_threshold_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_alpha_threshold_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_alpha_threshold_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_alpha_threshold_0_Pre(parms); + } + var region = parms.region; + var innerThreshold = parms.innerThreshold; + var outerThreshold = parms.outerThreshold; + var input = parms.input; + var ret = CanvasKit._sk_imagefilter_new_alpha_threshold(region, innerThreshold, outerThreshold, input); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_alpha_threshold_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_alpha_threshold_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_blur_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_blur_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_blur_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_blur_0_Pre(parms); + } + var sigmaX = parms.sigmaX; + var sigmaY = parms.sigmaY; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_blur(sigmaX, sigmaY, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_blur_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_blur_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_color_filter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_color_filter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_color_filter_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_color_filter_0_Pre(parms); + } + var cf = parms.cf; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_color_filter(cf, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_color_filter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_color_filter_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_compose_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_compose_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_compose_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_compose_0_Pre(parms); + } + var outer = parms.outer; + var inner = parms.inner; + var ret = CanvasKit._sk_imagefilter_new_compose(outer, inner); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_compose_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_compose_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_displacement_map_effect_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_displacement_map_effect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_displacement_map_effect_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_displacement_map_effect_0_Pre(parms); + } + var xChannelSelector = parms.xChannelSelector; + var yChannelSelector = parms.yChannelSelector; + var scale = parms.scale; + var displacement = parms.displacement; + var color = parms.color; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_displacement_map_effect(xChannelSelector, yChannelSelector, scale, displacement, color, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_displacement_map_effect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_displacement_map_effect_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_drop_shadow_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_drop_shadow_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_drop_shadow_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_drop_shadow_0_Pre(parms); + } + var dx = parms.dx; + var dy = parms.dy; + var sigmaX = parms.sigmaX; + var sigmaY = parms.sigmaY; + var color = parms.color.color; + var shadowMode = parms.shadowMode; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_drop_shadow(dx, dy, sigmaX, sigmaY, color, shadowMode, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_drop_shadow_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_drop_shadow_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_distant_lit_diffuse_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_distant_lit_diffuse_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_distant_lit_diffuse_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_diffuse_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_diffuse_0_Pre(parms); + } + var direction = parms.direction.marshalNew(CanvasKit); + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var kd = parms.kd; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_distant_lit_diffuse(direction, lightColor, surfaceScale, kd, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_distant_lit_diffuse_0_Return(); + retStruct.direction = SkiaSharp.SKPoint3.unmarshal(direction, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_diffuse_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_diffuse_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_point_lit_diffuse_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_point_lit_diffuse_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_point_lit_diffuse_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_diffuse_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_diffuse_0_Pre(parms); + } + var location = parms.location.marshalNew(CanvasKit); + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var kd = parms.kd; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_point_lit_diffuse(location, lightColor, surfaceScale, kd, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_point_lit_diffuse_0_Return(); + retStruct.location = SkiaSharp.SKPoint3.unmarshal(location, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_diffuse_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_diffuse_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_spot_lit_diffuse_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_spot_lit_diffuse_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_spot_lit_diffuse_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_diffuse_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_diffuse_0_Pre(parms); + } + var location = parms.location.marshalNew(CanvasKit); + var target = parms.target.marshalNew(CanvasKit); + var specularExponent = parms.specularExponent; + var cutoffAngle = parms.cutoffAngle; + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var kd = parms.kd; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_spot_lit_diffuse(location, target, specularExponent, cutoffAngle, lightColor, surfaceScale, kd, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_spot_lit_diffuse_0_Return(); + retStruct.location = SkiaSharp.SKPoint3.unmarshal(location, CanvasKit); + retStruct.target = SkiaSharp.SKPoint3.unmarshal(target, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_diffuse_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_diffuse_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_distant_lit_specular_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_distant_lit_specular_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_distant_lit_specular_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_specular_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_specular_0_Pre(parms); + } + var direction = parms.direction.marshalNew(CanvasKit); + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var ks = parms.ks; + var shininess = parms.shininess; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_distant_lit_specular(direction, lightColor, surfaceScale, ks, shininess, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_distant_lit_specular_0_Return(); + retStruct.direction = SkiaSharp.SKPoint3.unmarshal(direction, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_specular_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_distant_lit_specular_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_point_lit_specular_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_point_lit_specular_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_point_lit_specular_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_specular_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_specular_0_Pre(parms); + } + var location = parms.location.marshalNew(CanvasKit); + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var ks = parms.ks; + var shininess = parms.shininess; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_point_lit_specular(location, lightColor, surfaceScale, ks, shininess, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_point_lit_specular_0_Return(); + retStruct.location = SkiaSharp.SKPoint3.unmarshal(location, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_specular_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_point_lit_specular_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_spot_lit_specular_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_spot_lit_specular_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_spot_lit_specular_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_specular_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_specular_0_Pre(parms); + } + var location = parms.location.marshalNew(CanvasKit); + var target = parms.target.marshalNew(CanvasKit); + var specularExponent = parms.specularExponent; + var cutoffAngle = parms.cutoffAngle; + var lightColor = parms.lightColor.color; + var surfaceScale = parms.surfaceScale; + var ks = parms.ks; + var shininess = parms.shininess; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_spot_lit_specular(location, target, specularExponent, cutoffAngle, lightColor, surfaceScale, ks, shininess, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_spot_lit_specular_0_Return(); + retStruct.location = SkiaSharp.SKPoint3.unmarshal(location, CanvasKit); + retStruct.target = SkiaSharp.SKPoint3.unmarshal(target, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_specular_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_spot_lit_specular_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_magnifier_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_magnifier_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_magnifier_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_magnifier_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_magnifier_0_Pre(parms); + } + var src = parms.src.marshalNew(CanvasKit); + var inset = parms.inset; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_magnifier(src, inset, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_magnifier_0_Return(); + retStruct.src = SkiaSharp.SKRect.unmarshal(src, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_magnifier_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_magnifier_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_matrix_convolution_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_matrix_convolution_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_matrix_convolution_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_convolution_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_convolution_0_Pre(parms); + } + var kernelSize = parms.kernelSize.marshalNew(CanvasKit); + var kernel = CanvasKit._malloc(parms.kernel_Length * 4); /*float*/ + var kernel_f32 = kernel / 4; + { + for (var i = 0; i < parms.kernel_Length; i++) { + CanvasKit.HEAPF32[kernel_f32 + i] = parms.kernel[i]; + } + } + var gain = parms.gain; + var bias = parms.bias; + var kernelOffset = parms.kernelOffset.marshalNew(CanvasKit); + var tileMode = parms.tileMode; + var convolveAlpha = parms.convolveAlpha; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_matrix_convolution(kernelSize, kernel, gain, bias, kernelOffset, tileMode, convolveAlpha, input, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_matrix_convolution_0_Return(); + retStruct.kernelSize = SkiaSharp.SKSizeI.unmarshal(kernelSize, CanvasKit); + retStruct.kernelOffset = SkiaSharp.SKPointI.unmarshal(kernelOffset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_convolution_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_matrix_convolution_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_merge_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_merge_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_merge_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_merge_0_Pre(parms); + } + var filters = parms.filters; /* System.IntPtr */ + var count = parms.count; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_merge(filters, count, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_merge_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_merge_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_dilate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_dilate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_dilate_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_dilate_0_Pre(parms); + } + var radiusX = parms.radiusX; + var radiusY = parms.radiusY; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_dilate(radiusX, radiusY, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_dilate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_dilate_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_erode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_erode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_erode_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_erode_0_Pre(parms); + } + var radiusX = parms.radiusX; + var radiusY = parms.radiusY; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_erode(radiusX, radiusY, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_erode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_erode_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_offset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_offset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_offset_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_offset_0_Pre(parms); + } + var dx = parms.dx; + var dy = parms.dy; + var input = parms.input; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_offset(dx, dy, input, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_offset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_offset_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_picture_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_picture_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_picture_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_picture_0_Pre(parms); + } + var picture = parms.picture; + var ret = CanvasKit._sk_imagefilter_new_picture(picture); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_picture_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_picture_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_picture_with_croprect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_picture_with_croprect_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_picture_with_croprect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_picture_with_croprect_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_picture_with_croprect_0_Pre(parms); + } + var picture = parms.picture; + var cropRect = parms.cropRect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_imagefilter_new_picture_with_croprect(picture, cropRect); + var retStruct = new SkiaSharp.sk_imagefilter_new_picture_with_croprect_0_Return(); + retStruct.cropRect = SkiaSharp.SKRect.unmarshal(cropRect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_picture_with_croprect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_picture_with_croprect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_tile_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_tile_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_tile_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_tile_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_tile_0_Pre(parms); + } + var src = parms.src.marshalNew(CanvasKit); + var dst = parms.dst.marshalNew(CanvasKit); + var input = parms.input; + var ret = CanvasKit._sk_imagefilter_new_tile(src, dst, input); + var retStruct = new SkiaSharp.sk_imagefilter_new_tile_0_Return(); + retStruct.src = SkiaSharp.SKRect.unmarshal(src, CanvasKit); + retStruct.dst = SkiaSharp.SKRect.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_tile_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_tile_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_xfermode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_xfermode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_xfermode_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_xfermode_0_Pre(parms); + } + var mode = parms.mode; + var background = parms.background; + var foreground = parms.foreground; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_xfermode(mode, background, foreground, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_xfermode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_xfermode_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_arithmetic_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_arithmetic_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_arithmetic_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_arithmetic_0_Pre(parms); + } + var k1 = parms.k1; + var k2 = parms.k2; + var k3 = parms.k3; + var k4 = parms.k4; + var enforcePMColor = parms.enforcePMColor; + var background = parms.background; + var foreground = parms.foreground; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_arithmetic(k1, k2, k3, k4, enforcePMColor, background, foreground, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_arithmetic_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_arithmetic_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_image_source_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_imagefilter_new_image_source_0_Return(); + var parms = SkiaSharp.sk_imagefilter_new_image_source_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_0_Pre(parms); + } + var image = parms.image; + var srcRect = parms.srcRect.marshalNew(CanvasKit); + var dstRect = parms.dstRect.marshalNew(CanvasKit); + var filterQuality = parms.filterQuality; + var ret = CanvasKit._sk_imagefilter_new_image_source(image, srcRect, dstRect, filterQuality); + var retStruct = new SkiaSharp.sk_imagefilter_new_image_source_0_Return(); + retStruct.srcRect = SkiaSharp.SKRect.unmarshal(srcRect, CanvasKit); + retStruct.dstRect = SkiaSharp.SKRect.unmarshal(dstRect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_imagefilter_new_image_source_default_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_image_source_default_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_default_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_default_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_imagefilter_new_image_source_default(image); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_default_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_image_source_default_0_Post(ret, parms); + } + return ret; + } + static sk_imagefilter_new_paint_0(pParams, pReturn) { + var parms = SkiaSharp.sk_imagefilter_new_paint_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_paint_0_Pre) { + SkiaSharp.ApiOverride.sk_imagefilter_new_paint_0_Pre(parms); + } + var paint = parms.paint; + var cropRect = parms.cropRect; + var ret = CanvasKit._sk_imagefilter_new_paint(paint, cropRect); + if (SkiaSharp.ApiOverride.sk_imagefilter_new_paint_0_Post) { + ret = SkiaSharp.ApiOverride.sk_imagefilter_new_paint_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_unref_0_Pre(parms); + } + var filter = parms.filter; + var ret = CanvasKit._sk_colorfilter_unref(filter); + if (SkiaSharp.ApiOverride.sk_colorfilter_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_unref_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_mode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_mode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_mode_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_mode_0_Pre(parms); + } + var c = parms.c.color; + var mode = parms.mode; + var ret = CanvasKit._sk_colorfilter_new_mode(c, mode); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_mode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_mode_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_lighting_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_lighting_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_lighting_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_lighting_0_Pre(parms); + } + var mul = parms.mul.color; + var add = parms.add.color; + var ret = CanvasKit._sk_colorfilter_new_lighting(mul, add); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_lighting_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_lighting_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_compose_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_compose_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_compose_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_compose_0_Pre(parms); + } + var outer = parms.outer; + var inner = parms.inner; + var ret = CanvasKit._sk_colorfilter_new_compose(outer, inner); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_compose_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_compose_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_color_matrix_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_color_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_color_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_color_matrix_0_Pre(parms); + } + var array = CanvasKit._malloc(parms.array_Length * 4); /*float*/ + var array_f32 = array / 4; + { + for (var i = 0; i < parms.array_Length; i++) { + CanvasKit.HEAPF32[array_f32 + i] = parms.array[i]; + } + } + var ret = CanvasKit._sk_colorfilter_new_color_matrix(array); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_color_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_color_matrix_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_luma_color_0(pParams, pReturn) { + var ret = CanvasKit._sk_colorfilter_new_luma_color(); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_luma_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_luma_color_0_Post(ret); + } + return ret; + } + static sk_colorfilter_new_table_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_table_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_table_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_table_0_Pre(parms); + } + var table = CanvasKit._malloc(parms.table_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.table_Length; i++) { + CanvasKit.HEAPU8[table + i] = parms.table[i]; + } + } + var ret = CanvasKit._sk_colorfilter_new_table(table); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_table_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_table_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_table_argb_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colorfilter_new_table_argb_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_table_argb_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_table_argb_0_Pre(parms); + } + var tableA = CanvasKit._malloc(parms.tableA_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.tableA_Length; i++) { + CanvasKit.HEAPU8[tableA + i] = parms.tableA[i]; + } + } + var tableR = CanvasKit._malloc(parms.tableR_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.tableR_Length; i++) { + CanvasKit.HEAPU8[tableR + i] = parms.tableR[i]; + } + } + var tableG = CanvasKit._malloc(parms.tableG_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.tableG_Length; i++) { + CanvasKit.HEAPU8[tableG + i] = parms.tableG[i]; + } + } + var tableB = CanvasKit._malloc(parms.tableB_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.tableB_Length; i++) { + CanvasKit.HEAPU8[tableB + i] = parms.tableB[i]; + } + } + var ret = CanvasKit._sk_colorfilter_new_table_argb(tableA, tableR, tableG, tableB); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_table_argb_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_table_argb_0_Post(ret, parms); + } + return ret; + } + static sk_colorfilter_new_high_contrast_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colorfilter_new_high_contrast_0_Return(); + var parms = SkiaSharp.sk_colorfilter_new_high_contrast_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_high_contrast_0_Pre) { + SkiaSharp.ApiOverride.sk_colorfilter_new_high_contrast_0_Pre(parms); + } + var config = parms.config.marshalNew(CanvasKit); + var ret = CanvasKit._sk_colorfilter_new_high_contrast(config); + var retStruct = new SkiaSharp.sk_colorfilter_new_high_contrast_0_Return(); + retStruct.config = SkiaSharp.SKHighContrastConfig.unmarshal(config, CanvasKit); + if (SkiaSharp.ApiOverride.sk_colorfilter_new_high_contrast_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colorfilter_new_high_contrast_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_data_new_empty_0(pParams, pReturn) { + var ret = CanvasKit._sk_data_new_empty(); + if (SkiaSharp.ApiOverride.sk_data_new_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_empty_0_Post(ret); + } + return ret; + } + static sk_data_new_with_copy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_with_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_with_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_with_copy_0_Pre(parms); + } + var src = parms.src; + var length = parms.length; + var ret = CanvasKit._sk_data_new_with_copy(src, length); + if (SkiaSharp.ApiOverride.sk_data_new_with_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_with_copy_0_Post(ret, parms); + } + return ret; + } + static sk_data_new_with_copy_1(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_with_copy_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_with_copy_1_Pre) { + SkiaSharp.ApiOverride.sk_data_new_with_copy_1_Pre(parms); + } + var src = CanvasKit._malloc(parms.src_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.src_Length; i++) { + CanvasKit.HEAPU8[src + i] = parms.src[i]; + } + } + var length = parms.length; + var ret = CanvasKit._sk_data_new_with_copy(src, length); + if (SkiaSharp.ApiOverride.sk_data_new_with_copy_1_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_with_copy_1_Post(ret, parms); + } + return ret; + } + static sk_data_new_subset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_subset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_subset_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_subset_0_Pre(parms); + } + var src = parms.src; + var offset = parms.offset; + var length = parms.length; + var ret = CanvasKit._sk_data_new_subset(src, offset, length); + if (SkiaSharp.ApiOverride.sk_data_new_subset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_subset_0_Post(ret, parms); + } + return ret; + } + static sk_data_new_from_file_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_from_file_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_from_file_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_from_file_0_Pre(parms); + } + var utf8path = CanvasKit._malloc(parms.utf8path_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.utf8path_Length; i++) { + CanvasKit.HEAPU8[utf8path + i] = parms.utf8path[i]; + } + } + var ret = CanvasKit._sk_data_new_from_file(utf8path); + if (SkiaSharp.ApiOverride.sk_data_new_from_file_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_from_file_0_Post(ret, parms); + } + return ret; + } + static sk_data_new_from_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_from_stream_0_Pre(parms); + } + var stream = parms.stream; + var length = parms.length; + var ret = CanvasKit._sk_data_new_from_stream(stream, length); + if (SkiaSharp.ApiOverride.sk_data_new_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_from_stream_0_Post(ret, parms); + } + return ret; + } + static sk_data_new_with_proc_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_with_proc_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_with_proc_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_with_proc_0_Pre(parms); + } + var ptr = parms.ptr; + var length = parms.length; + var proc = parms.proc; + var ctx = parms.ctx; + var ret = CanvasKit._sk_data_new_with_proc(ptr, length, proc, ctx); + if (SkiaSharp.ApiOverride.sk_data_new_with_proc_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_with_proc_0_Post(ret, parms); + } + return ret; + } + static sk_data_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_data_unref_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_data_unref(d); + if (SkiaSharp.ApiOverride.sk_data_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_unref_0_Post(ret, parms); + } + return ret; + } + static sk_data_get_size_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_get_size_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_get_size_0_Pre) { + SkiaSharp.ApiOverride.sk_data_get_size_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_data_get_size(d); + if (SkiaSharp.ApiOverride.sk_data_get_size_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_get_size_0_Post(ret, parms); + } + return ret; + } + static sk_data_get_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_get_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_get_data_0_Pre) { + SkiaSharp.ApiOverride.sk_data_get_data_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_data_get_data(d); + if (SkiaSharp.ApiOverride.sk_data_get_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_get_data_0_Post(ret, parms); + } + return ret; + } + static sk_data_new_uninitialized_0(pParams, pReturn) { + var parms = SkiaSharp.sk_data_new_uninitialized_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_data_new_uninitialized_0_Pre) { + SkiaSharp.ApiOverride.sk_data_new_uninitialized_0_Pre(parms); + } + var size = parms.size; + var ret = CanvasKit._sk_data_new_uninitialized(size); + if (SkiaSharp.ApiOverride.sk_data_new_uninitialized_0_Post) { + ret = SkiaSharp.ApiOverride.sk_data_new_uninitialized_0_Post(ret, parms); + } + return ret; + } + static sk_string_new_empty_0(pParams, pReturn) { + var ret = CanvasKit._sk_string_new_empty(); + if (SkiaSharp.ApiOverride.sk_string_new_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_string_new_empty_0_Post(ret); + } + return ret; + } + static sk_string_new_with_copy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_string_new_with_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_string_new_with_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_string_new_with_copy_0_Pre(parms); + } + var src = CanvasKit._malloc(parms.src_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.src_Length; i++) { + CanvasKit.HEAPU8[src + i] = parms.src[i]; + } + } + var length = parms.length; + var ret = CanvasKit._sk_string_new_with_copy(src, length); + if (SkiaSharp.ApiOverride.sk_string_new_with_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_string_new_with_copy_0_Post(ret, parms); + } + return ret; + } + static sk_string_destructor_0(pParams, pReturn) { + var parms = SkiaSharp.sk_string_destructor_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_string_destructor_0_Pre) { + SkiaSharp.ApiOverride.sk_string_destructor_0_Pre(parms); + } + var skstring = parms.skstring; + var ret = CanvasKit._sk_string_destructor(skstring); + if (SkiaSharp.ApiOverride.sk_string_destructor_0_Post) { + ret = SkiaSharp.ApiOverride.sk_string_destructor_0_Post(ret, parms); + } + return ret; + } + static sk_string_get_size_0(pParams, pReturn) { + var parms = SkiaSharp.sk_string_get_size_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_string_get_size_0_Pre) { + SkiaSharp.ApiOverride.sk_string_get_size_0_Pre(parms); + } + var skstring = parms.skstring; + var ret = CanvasKit._sk_string_get_size(skstring); + if (SkiaSharp.ApiOverride.sk_string_get_size_0_Post) { + ret = SkiaSharp.ApiOverride.sk_string_get_size_0_Post(ret, parms); + } + return ret; + } + static sk_string_get_c_str_0(pParams, pReturn) { + var parms = SkiaSharp.sk_string_get_c_str_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_string_get_c_str_0_Pre) { + SkiaSharp.ApiOverride.sk_string_get_c_str_0_Pre(parms); + } + var skstring = parms.skstring; + var ret = CanvasKit._sk_string_get_c_str(skstring); + if (SkiaSharp.ApiOverride.sk_string_get_c_str_0_Post) { + ret = SkiaSharp.ApiOverride.sk_string_get_c_str_0_Post(ret, parms); + } + return ret; + } + static sk_picture_recorder_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_recorder_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_recorder_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_recorder_delete_0_Pre(parms); + } + var r = parms.r; + var ret = CanvasKit._sk_picture_recorder_delete(r); + if (SkiaSharp.ApiOverride.sk_picture_recorder_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_recorder_delete_0_Post(ret, parms); + } + return ret; + } + static sk_picture_recorder_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_picture_recorder_new(); + if (SkiaSharp.ApiOverride.sk_picture_recorder_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_recorder_new_0_Post(ret); + } + return ret; + } + static sk_picture_recorder_begin_recording_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_picture_recorder_begin_recording_0_Return(); + var parms = SkiaSharp.sk_picture_recorder_begin_recording_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_recorder_begin_recording_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_recorder_begin_recording_0_Pre(parms); + } + var r = parms.r; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_picture_recorder_begin_recording(r, rect); + var retStruct = new SkiaSharp.sk_picture_recorder_begin_recording_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_picture_recorder_begin_recording_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_recorder_begin_recording_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_picture_recorder_end_recording_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_recorder_end_recording_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_0_Pre(parms); + } + var r = parms.r; + var ret = CanvasKit._sk_picture_recorder_end_recording(r); + if (SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_0_Post(ret, parms); + } + return ret; + } + static sk_picture_recorder_end_recording_as_drawable_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_recorder_end_recording_as_drawable_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_as_drawable_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_as_drawable_0_Pre(parms); + } + var r = parms.r; + var ret = CanvasKit._sk_picture_recorder_end_recording_as_drawable(r); + if (SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_as_drawable_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_recorder_end_recording_as_drawable_0_Post(ret, parms); + } + return ret; + } + static sk_picture_get_recording_canvas_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_get_recording_canvas_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_get_recording_canvas_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_get_recording_canvas_0_Pre(parms); + } + var r = parms.r; + var ret = CanvasKit._sk_picture_get_recording_canvas(r); + if (SkiaSharp.ApiOverride.sk_picture_get_recording_canvas_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_get_recording_canvas_0_Post(ret, parms); + } + return ret; + } + static sk_picture_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_unref_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_picture_unref(t); + if (SkiaSharp.ApiOverride.sk_picture_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_unref_0_Post(ret, parms); + } + return ret; + } + static sk_picture_get_unique_id_0(pParams, pReturn) { + var parms = SkiaSharp.sk_picture_get_unique_id_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_get_unique_id_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_get_unique_id_0_Pre(parms); + } + var p = parms.p; + var ret = CanvasKit._sk_picture_get_unique_id(p); + if (SkiaSharp.ApiOverride.sk_picture_get_unique_id_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_get_unique_id_0_Post(ret, parms); + } + return ret; + } + static sk_picture_get_cull_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_picture_get_cull_rect_0_Return(); + var parms = SkiaSharp.sk_picture_get_cull_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_picture_get_cull_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_picture_get_cull_rect_0_Pre(parms); + } + var p = parms.p; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_picture_get_cull_rect(p, rect); + var retStruct = new SkiaSharp.sk_picture_get_cull_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_picture_get_cull_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_picture_get_cull_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_manageddrawable_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_manageddrawable_new(); + if (SkiaSharp.ApiOverride.sk_manageddrawable_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_manageddrawable_new_0_Post(ret); + } + return ret; + } + static sk_manageddrawable_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_manageddrawable_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_manageddrawable_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_manageddrawable_destroy_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_manageddrawable_destroy(t); + if (SkiaSharp.ApiOverride.sk_manageddrawable_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_manageddrawable_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_manageddrawable_set_delegates_0(pParams, pReturn) { + var parms = SkiaSharp.sk_manageddrawable_set_delegates_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_manageddrawable_set_delegates_0_Pre) { + SkiaSharp.ApiOverride.sk_manageddrawable_set_delegates_0_Pre(parms); + } + var pDraw = parms.pDraw; + var pGetBounds = parms.pGetBounds; + var pNewPictureSnapshot = parms.pNewPictureSnapshot; + var ret = CanvasKit._sk_manageddrawable_set_delegates(pDraw, pGetBounds, pNewPictureSnapshot); + if (SkiaSharp.ApiOverride.sk_manageddrawable_set_delegates_0_Post) { + ret = SkiaSharp.ApiOverride.sk_manageddrawable_set_delegates_0_Post(ret, parms); + } + return ret; + } + static sk_drawable_get_generation_id_0(pParams, pReturn) { + var parms = SkiaSharp.sk_drawable_get_generation_id_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_drawable_get_generation_id_0_Pre) { + SkiaSharp.ApiOverride.sk_drawable_get_generation_id_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_drawable_get_generation_id(d); + if (SkiaSharp.ApiOverride.sk_drawable_get_generation_id_0_Post) { + ret = SkiaSharp.ApiOverride.sk_drawable_get_generation_id_0_Post(ret, parms); + } + return ret; + } + static sk_drawable_get_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_drawable_get_bounds_0_Return(); + var parms = SkiaSharp.sk_drawable_get_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_drawable_get_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_drawable_get_bounds_0_Pre(parms); + } + var d = parms.d; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_drawable_get_bounds(d, rect); + var retStruct = new SkiaSharp.sk_drawable_get_bounds_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_drawable_get_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_drawable_get_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_drawable_draw_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_drawable_draw_0_Return(); + var parms = SkiaSharp.sk_drawable_draw_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_drawable_draw_0_Pre) { + SkiaSharp.ApiOverride.sk_drawable_draw_0_Pre(parms); + } + var d = parms.d; + var c = parms.c; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_drawable_draw(d, c, matrix); + var retStruct = new SkiaSharp.sk_drawable_draw_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_drawable_draw_0_Post) { + ret = SkiaSharp.ApiOverride.sk_drawable_draw_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_drawable_new_picture_snapshot_0(pParams, pReturn) { + var parms = SkiaSharp.sk_drawable_new_picture_snapshot_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_drawable_new_picture_snapshot_0_Pre) { + SkiaSharp.ApiOverride.sk_drawable_new_picture_snapshot_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_drawable_new_picture_snapshot(d); + if (SkiaSharp.ApiOverride.sk_drawable_new_picture_snapshot_0_Post) { + ret = SkiaSharp.ApiOverride.sk_drawable_new_picture_snapshot_0_Post(ret, parms); + } + return ret; + } + static sk_drawable_notify_drawing_changed_0(pParams, pReturn) { + var parms = SkiaSharp.sk_drawable_notify_drawing_changed_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_drawable_notify_drawing_changed_0_Pre) { + SkiaSharp.ApiOverride.sk_drawable_notify_drawing_changed_0_Pre(parms); + } + var d = parms.d; + var ret = CanvasKit._sk_drawable_notify_drawing_changed(d); + if (SkiaSharp.ApiOverride.sk_drawable_notify_drawing_changed_0_Post) { + ret = SkiaSharp.ApiOverride.sk_drawable_notify_drawing_changed_0_Post(ret, parms); + } + return ret; + } + static sk_shader_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_unref_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_shader_unref(t); + if (SkiaSharp.ApiOverride.sk_shader_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_unref_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_empty_0(pParams, pReturn) { + var ret = CanvasKit._sk_shader_new_empty(); + if (SkiaSharp.ApiOverride.sk_shader_new_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_empty_0_Post(ret); + } + return ret; + } + static sk_shader_new_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_color_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_color_0_Pre(parms); + } + var color = parms.color.color; + var ret = CanvasKit._sk_shader_new_color(color); + if (SkiaSharp.ApiOverride.sk_shader_new_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_color_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_local_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_local_matrix_0_Return(); + var parms = SkiaSharp.sk_shader_new_local_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_local_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_local_matrix_0_Pre(parms); + } + var proxy = parms.proxy; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_local_matrix(proxy, matrix); + var retStruct = new SkiaSharp.sk_shader_new_local_matrix_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_local_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_local_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_color_filter_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_color_filter_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_color_filter_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_color_filter_0_Pre(parms); + } + var proxy = parms.proxy; + var filter = parms.filter; + var ret = CanvasKit._sk_shader_new_color_filter(proxy, filter); + if (SkiaSharp.ApiOverride.sk_shader_new_color_filter_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_color_filter_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_bitmap_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_bitmap_0_Return(); + var parms = SkiaSharp.sk_shader_new_bitmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_bitmap_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_bitmap_0_Pre(parms); + } + var src = parms.src; + var tmx = parms.tmx; + var tmy = parms.tmy; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_bitmap(src, tmx, tmy, matrix); + var retStruct = new SkiaSharp.sk_shader_new_bitmap_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_bitmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_bitmap_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_bitmap_1(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_bitmap_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_bitmap_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_bitmap_1_Pre(parms); + } + var src = parms.src; + var tmx = parms.tmx; + var tmy = parms.tmy; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_bitmap(src, tmx, tmy, matrixZero); + if (SkiaSharp.ApiOverride.sk_shader_new_bitmap_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_bitmap_1_Post(ret, parms); + } + return ret; + } + static sk_shader_new_linear_gradient_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_linear_gradient_0_Return(); + var parms = SkiaSharp.sk_shader_new_linear_gradient_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_0_Pre(parms); + } + var points = parms.points; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_linear_gradient(points, colors, colorPos, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_linear_gradient_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_linear_gradient_1(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_linear_gradient_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_1_Pre(parms); + } + var points = parms.points; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_linear_gradient(points, colors, colorPos, count, mode, matrixZero); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_1_Post(ret, parms); + } + return ret; + } + static sk_shader_new_linear_gradient_2(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_linear_gradient_2_Return(); + var parms = SkiaSharp.sk_shader_new_linear_gradient_2_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_2_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_2_Pre(parms); + } + var points = parms.points; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_linear_gradient(points, colors, colorPosZero, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_linear_gradient_2_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_2_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_2_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_linear_gradient_3(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_linear_gradient_3_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_3_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_3_Pre(parms); + } + var points = parms.points; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_linear_gradient(points, colors, colorPosZero, count, mode, matrixZero); + if (SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_3_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_linear_gradient_3_Post(ret, parms); + } + return ret; + } + static sk_shader_new_radial_gradient_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_0_Return(); + var parms = SkiaSharp.sk_shader_new_radial_gradient_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_0_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var radius = parms.radius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_radial_gradient(center, radius, colors, colorPos, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_0_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_radial_gradient_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_1_Return(); + var parms = SkiaSharp.sk_shader_new_radial_gradient_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_1_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var radius = parms.radius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_radial_gradient(center, radius, colors, colorPos, count, mode, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_1_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_radial_gradient_2(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_2_Return(); + var parms = SkiaSharp.sk_shader_new_radial_gradient_2_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_2_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_2_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var radius = parms.radius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_radial_gradient(center, radius, colors, colorPosZero, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_2_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_2_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_2_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_radial_gradient_3(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_3_Return(); + var parms = SkiaSharp.sk_shader_new_radial_gradient_3_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_3_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_3_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var radius = parms.radius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_radial_gradient(center, radius, colors, colorPosZero, count, mode, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_radial_gradient_3_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_3_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_radial_gradient_3_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_sweep_gradient_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_0_Return(); + var parms = SkiaSharp.sk_shader_new_sweep_gradient_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_0_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var startAngle = parms.startAngle; + var endAngle = parms.endAngle; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_sweep_gradient(center, colors, colorPos, count, mode, startAngle, endAngle, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_0_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_sweep_gradient_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_1_Return(); + var parms = SkiaSharp.sk_shader_new_sweep_gradient_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_1_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var startAngle = parms.startAngle; + var endAngle = parms.endAngle; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_sweep_gradient(center, colors, colorPos, count, mode, startAngle, endAngle, matrix); + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_1_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_sweep_gradient_2(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_2_Return(); + var parms = SkiaSharp.sk_shader_new_sweep_gradient_2_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_2_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_2_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var startAngle = parms.startAngle; + var endAngle = parms.endAngle; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_sweep_gradient(center, colors, colorPosZero, count, mode, startAngle, endAngle, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_2_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_2_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_2_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_sweep_gradient_3(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_3_Return(); + var parms = SkiaSharp.sk_shader_new_sweep_gradient_3_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_3_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_3_Pre(parms); + } + var center = parms.center.marshalNew(CanvasKit); + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var startAngle = parms.startAngle; + var endAngle = parms.endAngle; + var matrixZero = parms.matrixZero.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_sweep_gradient(center, colors, colorPosZero, count, mode, startAngle, endAngle, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_sweep_gradient_3_Return(); + retStruct.center = SkiaSharp.SKPoint.unmarshal(center, CanvasKit); + retStruct.matrixZero = SkiaSharp.SKMatrix.unmarshal(matrixZero, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_3_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_sweep_gradient_3_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_two_point_conical_gradient_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_0_Return(); + var parms = SkiaSharp.sk_shader_new_two_point_conical_gradient_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_0_Pre(parms); + } + var start = parms.start.marshalNew(CanvasKit); + var startRadius = parms.startRadius; + var end = parms.end.marshalNew(CanvasKit); + var endRadius = parms.endRadius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_two_point_conical_gradient(start, startRadius, end, endRadius, colors, colorPos, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_0_Return(); + retStruct.start = SkiaSharp.SKPoint.unmarshal(start, CanvasKit); + retStruct.end = SkiaSharp.SKPoint.unmarshal(end, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_two_point_conical_gradient_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_1_Return(); + var parms = SkiaSharp.sk_shader_new_two_point_conical_gradient_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_1_Pre(parms); + } + var start = parms.start.marshalNew(CanvasKit); + var startRadius = parms.startRadius; + var end = parms.end.marshalNew(CanvasKit); + var endRadius = parms.endRadius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPos = CanvasKit._malloc(parms.colorPos_Length * 4); /*float*/ + var colorPos_f32 = colorPos / 4; + { + for (var i = 0; i < parms.colorPos_Length; i++) { + CanvasKit.HEAPF32[colorPos_f32 + i] = parms.colorPos[i]; + } + } + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_two_point_conical_gradient(start, startRadius, end, endRadius, colors, colorPos, count, mode, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_1_Return(); + retStruct.start = SkiaSharp.SKPoint.unmarshal(start, CanvasKit); + retStruct.end = SkiaSharp.SKPoint.unmarshal(end, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_two_point_conical_gradient_2(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_2_Return(); + var parms = SkiaSharp.sk_shader_new_two_point_conical_gradient_2_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_2_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_2_Pre(parms); + } + var start = parms.start.marshalNew(CanvasKit); + var startRadius = parms.startRadius; + var end = parms.end.marshalNew(CanvasKit); + var endRadius = parms.endRadius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_two_point_conical_gradient(start, startRadius, end, endRadius, colors, colorPosZero, count, mode, matrix); + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_2_Return(); + retStruct.start = SkiaSharp.SKPoint.unmarshal(start, CanvasKit); + retStruct.end = SkiaSharp.SKPoint.unmarshal(end, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_2_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_2_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_two_point_conical_gradient_3(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_3_Return(); + var parms = SkiaSharp.sk_shader_new_two_point_conical_gradient_3_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_3_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_3_Pre(parms); + } + var start = parms.start.marshalNew(CanvasKit); + var startRadius = parms.startRadius; + var end = parms.end.marshalNew(CanvasKit); + var endRadius = parms.endRadius; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var colorPosZero = parms.colorPosZero; + var count = parms.count; + var mode = parms.mode; + var matrixZero = parms.matrixZero; + var ret = CanvasKit._sk_shader_new_two_point_conical_gradient(start, startRadius, end, endRadius, colors, colorPosZero, count, mode, matrixZero); + var retStruct = new SkiaSharp.sk_shader_new_two_point_conical_gradient_3_Return(); + retStruct.start = SkiaSharp.SKPoint.unmarshal(start, CanvasKit); + retStruct.end = SkiaSharp.SKPoint.unmarshal(end, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_3_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_two_point_conical_gradient_3_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_perlin_noise_fractal_noise_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_0_Pre(parms); + } + var baseFrequencyX = parms.baseFrequencyX; + var baseFrequencyY = parms.baseFrequencyY; + var numOctaves = parms.numOctaves; + var seed = parms.seed; + var tileSizeZero = parms.tileSizeZero; + var ret = CanvasKit._sk_shader_new_perlin_noise_fractal_noise(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSizeZero); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_perlin_noise_fractal_noise_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_1_Return(); + var parms = SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_1_Pre(parms); + } + var baseFrequencyX = parms.baseFrequencyX; + var baseFrequencyY = parms.baseFrequencyY; + var numOctaves = parms.numOctaves; + var seed = parms.seed; + var tileSize = parms.tileSize.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_perlin_noise_fractal_noise(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize); + var retStruct = new SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_1_Return(); + retStruct.tileSize = SkiaSharp.SKPointI.unmarshal(tileSize, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_fractal_noise_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_perlin_noise_turbulence_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_perlin_noise_turbulence_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_0_Pre(parms); + } + var baseFrequencyX = parms.baseFrequencyX; + var baseFrequencyY = parms.baseFrequencyY; + var numOctaves = parms.numOctaves; + var seed = parms.seed; + var tileSizeZero = parms.tileSizeZero; + var ret = CanvasKit._sk_shader_new_perlin_noise_turbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSizeZero); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_perlin_noise_turbulence_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_shader_new_perlin_noise_turbulence_1_Return(); + var parms = SkiaSharp.sk_shader_new_perlin_noise_turbulence_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_1_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_1_Pre(parms); + } + var baseFrequencyX = parms.baseFrequencyX; + var baseFrequencyY = parms.baseFrequencyY; + var numOctaves = parms.numOctaves; + var seed = parms.seed; + var tileSize = parms.tileSize.marshalNew(CanvasKit); + var ret = CanvasKit._sk_shader_new_perlin_noise_turbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize); + var retStruct = new SkiaSharp.sk_shader_new_perlin_noise_turbulence_1_Return(); + retStruct.tileSize = SkiaSharp.SKPointI.unmarshal(tileSize, CanvasKit); + if (SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_1_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_perlin_noise_turbulence_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_shader_new_compose_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_compose_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_compose_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_compose_0_Pre(parms); + } + var shaderA = parms.shaderA; + var shaderB = parms.shaderB; + var ret = CanvasKit._sk_shader_new_compose(shaderA, shaderB); + if (SkiaSharp.ApiOverride.sk_shader_new_compose_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_compose_0_Post(ret, parms); + } + return ret; + } + static sk_shader_new_compose_with_mode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_shader_new_compose_with_mode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_shader_new_compose_with_mode_0_Pre) { + SkiaSharp.ApiOverride.sk_shader_new_compose_with_mode_0_Pre(parms); + } + var shaderA = parms.shaderA; + var shaderB = parms.shaderB; + var mode = parms.mode; + var ret = CanvasKit._sk_shader_new_compose_with_mode(shaderA, shaderB, mode); + if (SkiaSharp.ApiOverride.sk_shader_new_compose_with_mode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_shader_new_compose_with_mode_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_create_default_0(pParams, pReturn) { + var ret = CanvasKit._sk_typeface_create_default(); + if (SkiaSharp.ApiOverride.sk_typeface_create_default_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_create_default_0_Post(ret); + } + return ret; + } + static sk_typeface_ref_default_0(pParams, pReturn) { + var ret = CanvasKit._sk_typeface_ref_default(); + if (SkiaSharp.ApiOverride.sk_typeface_ref_default_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_ref_default_0_Post(ret); + } + return ret; + } + static sk_typeface_create_from_name_with_font_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_create_from_name_with_font_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_name_with_font_style_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_create_from_name_with_font_style_0_Pre(parms); + } + var familyName_Length = parms.familyName.length * 4 + 1; + var familyName = CanvasKit._malloc(familyName_Length); + CanvasKit.stringToUTF8(parms.familyName, familyName, familyName_Length); + var style = parms.style; + var ret = CanvasKit._sk_typeface_create_from_name_with_font_style(familyName, style); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_name_with_font_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_create_from_name_with_font_style_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_create_from_file_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_create_from_file_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_file_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_create_from_file_0_Pre(parms); + } + var utf8path = CanvasKit._malloc(parms.utf8path_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.utf8path_Length; i++) { + CanvasKit.HEAPU8[utf8path + i] = parms.utf8path[i]; + } + } + var index = parms.index; + var ret = CanvasKit._sk_typeface_create_from_file(utf8path, index); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_file_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_create_from_file_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_create_from_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_create_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_create_from_stream_0_Pre(parms); + } + var stream = parms.stream; + var index = parms.index; + var ret = CanvasKit._sk_typeface_create_from_stream(stream, index); + if (SkiaSharp.ApiOverride.sk_typeface_create_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_create_from_stream_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_unref_0_Pre(parms); + } + var t = parms.t; + var ret = CanvasKit._sk_typeface_unref(t); + if (SkiaSharp.ApiOverride.sk_typeface_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_unref_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_chars_to_glyphs_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_chars_to_glyphs_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_chars_to_glyphs_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_chars_to_glyphs_0_Pre(parms); + } + var t = parms.t; + var chars = parms.chars; + var encoding = parms.encoding; + var glyphPtr = parms.glyphPtr; + var glyphCount = parms.glyphCount; + var ret = CanvasKit._sk_typeface_chars_to_glyphs(t, chars, encoding, glyphPtr, glyphCount); + if (SkiaSharp.ApiOverride.sk_typeface_chars_to_glyphs_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_chars_to_glyphs_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_family_name_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_family_name_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_family_name_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_family_name_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_family_name(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_family_name_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_family_name_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_count_tables_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_count_tables_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_count_tables_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_count_tables_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_count_tables(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_count_tables_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_count_tables_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_table_tags_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_table_tags_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_tags_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_table_tags_0_Pre(parms); + } + var typeface = parms.typeface; + var tags = parms.tags; /* uint */ + var ret = CanvasKit._sk_typeface_get_table_tags(typeface, tags); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_tags_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_table_tags_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_table_size_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_table_size_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_size_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_table_size_0_Pre(parms); + } + var typeface = parms.typeface; + var tag = parms.tag; + var ret = CanvasKit._sk_typeface_get_table_size(typeface, tag); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_size_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_table_size_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_table_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_table_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_data_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_table_data_0_Pre(parms); + } + var typeface = parms.typeface; + var tag = parms.tag; + var offset = parms.offset; + var length = parms.length; + var data = CanvasKit._malloc(parms.data_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.data_Length; i++) { + CanvasKit.HEAPU8[data + i] = parms.data[i]; + } + } + var ret = CanvasKit._sk_typeface_get_table_data(typeface, tag, offset, length, data); + if (SkiaSharp.ApiOverride.sk_typeface_get_table_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_table_data_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_fontstyle_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_fontstyle_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_fontstyle_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_fontstyle_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_fontstyle(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_fontstyle_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_fontstyle_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_font_weight_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_font_weight_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_weight_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_font_weight_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_font_weight(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_weight_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_font_weight_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_font_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_font_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_width_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_font_width_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_font_width(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_font_width_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_get_font_slant_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_font_slant_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_slant_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_font_slant_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_font_slant(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_font_slant_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_font_slant_0_Post(ret, parms); + } + return ret; + } + static sk_typeface_open_stream_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_typeface_open_stream_0_Return(); + var parms = SkiaSharp.sk_typeface_open_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_open_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_open_stream_0_Pre(parms); + } + var typeface = parms.typeface; + var ttcIndex = CanvasKit._malloc(4); + var ret = CanvasKit._sk_typeface_open_stream(typeface, ttcIndex); + var retStruct = new SkiaSharp.sk_typeface_open_stream_0_Return(); + retStruct.ttcIndex = CanvasKit.getValue(ttcIndex, "i32"); + if (SkiaSharp.ApiOverride.sk_typeface_open_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_open_stream_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_typeface_get_units_per_em_0(pParams, pReturn) { + var parms = SkiaSharp.sk_typeface_get_units_per_em_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_typeface_get_units_per_em_0_Pre) { + SkiaSharp.ApiOverride.sk_typeface_get_units_per_em_0_Pre(parms); + } + var typeface = parms.typeface; + var ret = CanvasKit._sk_typeface_get_units_per_em(typeface); + if (SkiaSharp.ApiOverride.sk_typeface_get_units_per_em_0_Post) { + ret = SkiaSharp.ApiOverride.sk_typeface_get_units_per_em_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_create_default_0(pParams, pReturn) { + var ret = CanvasKit._sk_fontmgr_create_default(); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_default_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_create_default_0_Post(ret); + } + return ret; + } + static sk_fontmgr_ref_default_0(pParams, pReturn) { + var ret = CanvasKit._sk_fontmgr_ref_default(); + if (SkiaSharp.ApiOverride.sk_fontmgr_ref_default_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_ref_default_0_Post(ret); + } + return ret; + } + static sk_fontmgr_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_unref_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var ret = CanvasKit._sk_fontmgr_unref(fontmgr); + if (SkiaSharp.ApiOverride.sk_fontmgr_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_unref_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_count_families_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_count_families_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_count_families_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_count_families_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var ret = CanvasKit._sk_fontmgr_count_families(fontmgr); + if (SkiaSharp.ApiOverride.sk_fontmgr_count_families_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_count_families_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_get_family_name_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_get_family_name_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_get_family_name_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_get_family_name_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var index = parms.index; + var familyName = parms.familyName; + var ret = CanvasKit._sk_fontmgr_get_family_name(fontmgr, index, familyName); + if (SkiaSharp.ApiOverride.sk_fontmgr_get_family_name_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_get_family_name_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_match_family_style_character_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_match_family_style_character_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_character_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_character_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var familyName_Length = parms.familyName.length * 4 + 1; + var familyName = CanvasKit._malloc(familyName_Length); + CanvasKit.stringToUTF8(parms.familyName, familyName, familyName_Length); + var style = parms.style; + var bcp47 = parms.bcp47; /* string */ + var bcp47Count = parms.bcp47Count; + var character = parms.character; + var ret = CanvasKit._sk_fontmgr_match_family_style_character(fontmgr, familyName, style, bcp47, bcp47Count, character); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_character_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_character_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_create_styleset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_create_styleset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_styleset_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_create_styleset_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var index = parms.index; + var ret = CanvasKit._sk_fontmgr_create_styleset(fontmgr, index); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_styleset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_create_styleset_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_match_family_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_match_family_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_match_family_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var familyName_Length = parms.familyName.length * 4 + 1; + var familyName = CanvasKit._malloc(familyName_Length); + CanvasKit.stringToUTF8(parms.familyName, familyName, familyName_Length); + var ret = CanvasKit._sk_fontmgr_match_family(fontmgr, familyName); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_match_family_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_match_family_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_match_family_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var familyName_Length = parms.familyName.length * 4 + 1; + var familyName = CanvasKit._malloc(familyName_Length); + CanvasKit.stringToUTF8(parms.familyName, familyName, familyName_Length); + var style = parms.style; + var ret = CanvasKit._sk_fontmgr_match_family_style(fontmgr, familyName, style); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_match_family_style_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_match_face_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_match_face_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_face_style_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_match_face_style_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var face = parms.face; + var style = parms.style; + var ret = CanvasKit._sk_fontmgr_match_face_style(fontmgr, face, style); + if (SkiaSharp.ApiOverride.sk_fontmgr_match_face_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_match_face_style_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_create_from_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_create_from_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_data_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_create_from_data_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var data = parms.data; + var index = parms.index; + var ret = CanvasKit._sk_fontmgr_create_from_data(fontmgr, data, index); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_create_from_data_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_create_from_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_create_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_create_from_stream_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var stream = parms.stream; + var index = parms.index; + var ret = CanvasKit._sk_fontmgr_create_from_stream(fontmgr, stream, index); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_create_from_stream_0_Post(ret, parms); + } + return ret; + } + static sk_fontmgr_create_from_file_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontmgr_create_from_file_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_file_0_Pre) { + SkiaSharp.ApiOverride.sk_fontmgr_create_from_file_0_Pre(parms); + } + var fontmgr = parms.fontmgr; + var utf8path = CanvasKit._malloc(parms.utf8path_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.utf8path_Length; i++) { + CanvasKit.HEAPU8[utf8path + i] = parms.utf8path[i]; + } + } + var index = parms.index; + var ret = CanvasKit._sk_fontmgr_create_from_file(fontmgr, utf8path, index); + if (SkiaSharp.ApiOverride.sk_fontmgr_create_from_file_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontmgr_create_from_file_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyle_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyle_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyle_new_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyle_new_0_Pre(parms); + } + var weight = parms.weight; + var width = parms.width; + var slant = parms.slant; + var ret = CanvasKit._sk_fontstyle_new(weight, width, slant); + if (SkiaSharp.ApiOverride.sk_fontstyle_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyle_new_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyle_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyle_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyle_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyle_delete_0_Pre(parms); + } + var fs = parms.fs; + var ret = CanvasKit._sk_fontstyle_delete(fs); + if (SkiaSharp.ApiOverride.sk_fontstyle_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyle_delete_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyle_get_weight_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyle_get_weight_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_weight_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyle_get_weight_0_Pre(parms); + } + var fs = parms.fs; + var ret = CanvasKit._sk_fontstyle_get_weight(fs); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_weight_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyle_get_weight_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyle_get_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyle_get_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_width_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyle_get_width_0_Pre(parms); + } + var fs = parms.fs; + var ret = CanvasKit._sk_fontstyle_get_width(fs); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyle_get_width_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyle_get_slant_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyle_get_slant_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_slant_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyle_get_slant_0_Pre(parms); + } + var fs = parms.fs; + var ret = CanvasKit._sk_fontstyle_get_slant(fs); + if (SkiaSharp.ApiOverride.sk_fontstyle_get_slant_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyle_get_slant_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyleset_create_empty_0(pParams, pReturn) { + var ret = CanvasKit._sk_fontstyleset_create_empty(); + if (SkiaSharp.ApiOverride.sk_fontstyleset_create_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_create_empty_0_Post(ret); + } + return ret; + } + static sk_fontstyleset_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyleset_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyleset_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyleset_unref_0_Pre(parms); + } + var fss = parms.fss; + var ret = CanvasKit._sk_fontstyleset_unref(fss); + if (SkiaSharp.ApiOverride.sk_fontstyleset_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_unref_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyleset_get_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyleset_get_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyleset_get_count_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyleset_get_count_0_Pre(parms); + } + var fss = parms.fss; + var ret = CanvasKit._sk_fontstyleset_get_count(fss); + if (SkiaSharp.ApiOverride.sk_fontstyleset_get_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_get_count_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyleset_get_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyleset_get_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyleset_get_style_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyleset_get_style_0_Pre(parms); + } + var fss = parms.fss; + var index = parms.index; + var fs = parms.fs; + var style = parms.style; + var ret = CanvasKit._sk_fontstyleset_get_style(fss, index, fs, style); + if (SkiaSharp.ApiOverride.sk_fontstyleset_get_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_get_style_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyleset_create_typeface_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyleset_create_typeface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyleset_create_typeface_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyleset_create_typeface_0_Pre(parms); + } + var fss = parms.fss; + var index = parms.index; + var ret = CanvasKit._sk_fontstyleset_create_typeface(fss, index); + if (SkiaSharp.ApiOverride.sk_fontstyleset_create_typeface_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_create_typeface_0_Post(ret, parms); + } + return ret; + } + static sk_fontstyleset_match_style_0(pParams, pReturn) { + var parms = SkiaSharp.sk_fontstyleset_match_style_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_fontstyleset_match_style_0_Pre) { + SkiaSharp.ApiOverride.sk_fontstyleset_match_style_0_Pre(parms); + } + var fss = parms.fss; + var style = parms.style; + var ret = CanvasKit._sk_fontstyleset_match_style(fss, style); + if (SkiaSharp.ApiOverride.sk_fontstyleset_match_style_0_Post) { + ret = SkiaSharp.ApiOverride.sk_fontstyleset_match_style_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_destroy_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_memorystream_destroy(stream); + if (SkiaSharp.ApiOverride.sk_memorystream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_filestream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filestream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filestream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_filestream_destroy_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_filestream_destroy(stream); + if (SkiaSharp.ApiOverride.sk_filestream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filestream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_stream_asset_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_asset_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_asset_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_asset_destroy_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_asset_destroy(stream); + if (SkiaSharp.ApiOverride.sk_stream_asset_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_asset_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_stream_read_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_read_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_0_Pre(parms); + } + var stream = parms.stream; + var buffer = parms.buffer; + var size = parms.size; + var ret = CanvasKit._sk_stream_read(stream, buffer, size); + if (SkiaSharp.ApiOverride.sk_stream_read_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_0_Post(ret, parms); + } + return ret; + } + static sk_stream_peek_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_peek_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_peek_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_peek_0_Pre(parms); + } + var stream = parms.stream; + var buffer = parms.buffer; + var size = parms.size; + var ret = CanvasKit._sk_stream_peek(stream, buffer, size); + if (SkiaSharp.ApiOverride.sk_stream_peek_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_peek_0_Post(ret, parms); + } + return ret; + } + static sk_stream_skip_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_skip_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_skip_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_skip_0_Pre(parms); + } + var stream = parms.stream; + var size = parms.size; + var ret = CanvasKit._sk_stream_skip(stream, size); + if (SkiaSharp.ApiOverride.sk_stream_skip_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_skip_0_Post(ret, parms); + } + return ret; + } + static sk_stream_is_at_end_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_is_at_end_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_is_at_end_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_is_at_end_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_is_at_end(stream); + if (SkiaSharp.ApiOverride.sk_stream_is_at_end_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_is_at_end_0_Post(ret, parms); + } + return ret; + } + static sk_stream_read_s8_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_s8_0_Return(); + var parms = SkiaSharp.sk_stream_read_s8_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_s8_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_s8_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(1); + var ret = CanvasKit._sk_stream_read_s8(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_s8_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i8"); + if (SkiaSharp.ApiOverride.sk_stream_read_s8_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_s8_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_s16_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_s16_0_Return(); + var parms = SkiaSharp.sk_stream_read_s16_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_s16_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_s16_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(2); + var ret = CanvasKit._sk_stream_read_s16(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_s16_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i16"); + if (SkiaSharp.ApiOverride.sk_stream_read_s16_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_s16_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_s32_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_s32_0_Return(); + var parms = SkiaSharp.sk_stream_read_s32_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_s32_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_s32_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(4); + var ret = CanvasKit._sk_stream_read_s32(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_s32_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i32"); + if (SkiaSharp.ApiOverride.sk_stream_read_s32_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_s32_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_u8_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_u8_0_Return(); + var parms = SkiaSharp.sk_stream_read_u8_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_u8_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_u8_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(1); + var ret = CanvasKit._sk_stream_read_u8(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_u8_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i8"); + if (SkiaSharp.ApiOverride.sk_stream_read_u8_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_u8_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_u16_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_u16_0_Return(); + var parms = SkiaSharp.sk_stream_read_u16_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_u16_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_u16_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(2); + var ret = CanvasKit._sk_stream_read_u16(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_u16_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i16"); + if (SkiaSharp.ApiOverride.sk_stream_read_u16_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_u16_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_u32_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_u32_0_Return(); + var parms = SkiaSharp.sk_stream_read_u32_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_u32_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_u32_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(4); + var ret = CanvasKit._sk_stream_read_u32(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_u32_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i32"); + if (SkiaSharp.ApiOverride.sk_stream_read_u32_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_u32_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_read_bool_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_stream_read_bool_0_Return(); + var parms = SkiaSharp.sk_stream_read_bool_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_read_bool_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_read_bool_0_Pre(parms); + } + var stream = parms.stream; + var buffer = CanvasKit._malloc(4); + var ret = CanvasKit._sk_stream_read_bool(stream, buffer); + var retStruct = new SkiaSharp.sk_stream_read_bool_0_Return(); + retStruct.buffer = CanvasKit.getValue(buffer, "i32"); + if (SkiaSharp.ApiOverride.sk_stream_read_bool_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_read_bool_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_stream_rewind_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_rewind_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_rewind_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_rewind_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_rewind(stream); + if (SkiaSharp.ApiOverride.sk_stream_rewind_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_rewind_0_Post(ret, parms); + } + return ret; + } + static sk_stream_has_position_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_has_position_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_has_position_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_has_position_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_has_position(stream); + if (SkiaSharp.ApiOverride.sk_stream_has_position_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_has_position_0_Post(ret, parms); + } + return ret; + } + static sk_stream_get_position_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_get_position_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_get_position_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_get_position_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_get_position(stream); + if (SkiaSharp.ApiOverride.sk_stream_get_position_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_get_position_0_Post(ret, parms); + } + return ret; + } + static sk_stream_seek_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_seek_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_seek_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_seek_0_Pre(parms); + } + var stream = parms.stream; + var position = parms.position; + var ret = CanvasKit._sk_stream_seek(stream, position); + if (SkiaSharp.ApiOverride.sk_stream_seek_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_seek_0_Post(ret, parms); + } + return ret; + } + static sk_stream_move_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_move_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_move_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_move_0_Pre(parms); + } + var stream = parms.stream; + var offset = parms.offset; + var ret = CanvasKit._sk_stream_move(stream, offset); + if (SkiaSharp.ApiOverride.sk_stream_move_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_move_0_Post(ret, parms); + } + return ret; + } + static sk_stream_has_length_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_has_length_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_has_length_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_has_length_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_has_length(stream); + if (SkiaSharp.ApiOverride.sk_stream_has_length_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_has_length_0_Post(ret, parms); + } + return ret; + } + static sk_stream_get_length_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_get_length_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_get_length_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_get_length_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_stream_get_length(stream); + if (SkiaSharp.ApiOverride.sk_stream_get_length_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_get_length_0_Post(ret, parms); + } + return ret; + } + static sk_stream_get_memory_base_0(pParams, pReturn) { + var parms = SkiaSharp.sk_stream_get_memory_base_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_stream_get_memory_base_0_Pre) { + SkiaSharp.ApiOverride.sk_stream_get_memory_base_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_stream_get_memory_base(cstream); + if (SkiaSharp.ApiOverride.sk_stream_get_memory_base_0_Post) { + ret = SkiaSharp.ApiOverride.sk_stream_get_memory_base_0_Post(ret, parms); + } + return ret; + } + static sk_filestream_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filestream_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filestream_new_0_Pre) { + SkiaSharp.ApiOverride.sk_filestream_new_0_Pre(parms); + } + var utf8path = CanvasKit._malloc(parms.utf8path_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.utf8path_Length; i++) { + CanvasKit.HEAPU8[utf8path + i] = parms.utf8path[i]; + } + } + var ret = CanvasKit._sk_filestream_new(utf8path); + if (SkiaSharp.ApiOverride.sk_filestream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filestream_new_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_memorystream_new(); + if (SkiaSharp.ApiOverride.sk_memorystream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_new_0_Post(ret); + } + return ret; + } + static sk_memorystream_new_with_length_0(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_new_with_length_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_length_0_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_new_with_length_0_Pre(parms); + } + var length = parms.length; + var ret = CanvasKit._sk_memorystream_new_with_length(length); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_length_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_new_with_length_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_new_with_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_new_with_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_data_0_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_new_with_data_0_Pre(parms); + } + var data = parms.data; + var length = parms.length; + var copyData = parms.copyData; + var ret = CanvasKit._sk_memorystream_new_with_data(data, length, copyData); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_new_with_data_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_new_with_data_1(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_new_with_data_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_data_1_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_new_with_data_1_Pre(parms); + } + var data = CanvasKit._malloc(parms.data_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.data_Length; i++) { + CanvasKit.HEAPU8[data + i] = parms.data[i]; + } + } + var length = parms.length; + var copyData = parms.copyData; + var ret = CanvasKit._sk_memorystream_new_with_data(data, length, copyData); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_data_1_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_new_with_data_1_Post(ret, parms); + } + return ret; + } + static sk_memorystream_new_with_skdata_0(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_new_with_skdata_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_skdata_0_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_new_with_skdata_0_Pre(parms); + } + var data = parms.data; + var ret = CanvasKit._sk_memorystream_new_with_skdata(data); + if (SkiaSharp.ApiOverride.sk_memorystream_new_with_skdata_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_new_with_skdata_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_set_memory_0(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_set_memory_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_set_memory_0_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_set_memory_0_Pre(parms); + } + var s = parms.s; + var data = parms.data; + var length = parms.length; + var copyData = parms.copyData; + var ret = CanvasKit._sk_memorystream_set_memory(s, data, length, copyData); + if (SkiaSharp.ApiOverride.sk_memorystream_set_memory_0_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_set_memory_0_Post(ret, parms); + } + return ret; + } + static sk_memorystream_set_memory_1(pParams, pReturn) { + var parms = SkiaSharp.sk_memorystream_set_memory_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_memorystream_set_memory_1_Pre) { + SkiaSharp.ApiOverride.sk_memorystream_set_memory_1_Pre(parms); + } + var s = parms.s; + var data = CanvasKit._malloc(parms.data_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.data_Length; i++) { + CanvasKit.HEAPU8[data + i] = parms.data[i]; + } + } + var length = parms.length; + var copyData = parms.copyData; + var ret = CanvasKit._sk_memorystream_set_memory(s, data, length, copyData); + if (SkiaSharp.ApiOverride.sk_memorystream_set_memory_1_Post) { + ret = SkiaSharp.ApiOverride.sk_memorystream_set_memory_1_Post(ret, parms); + } + return ret; + } + static sk_filestream_is_valid_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filestream_is_valid_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filestream_is_valid_0_Pre) { + SkiaSharp.ApiOverride.sk_filestream_is_valid_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_filestream_is_valid(cstream); + if (SkiaSharp.ApiOverride.sk_filestream_is_valid_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filestream_is_valid_0_Post(ret, parms); + } + return ret; + } + static sk_managedstream_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_managedstream_new(); + if (SkiaSharp.ApiOverride.sk_managedstream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedstream_new_0_Post(ret); + } + return ret; + } + static sk_managedstream_set_delegates_0(pParams, pReturn) { + var parms = SkiaSharp.sk_managedstream_set_delegates_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_managedstream_set_delegates_0_Pre) { + SkiaSharp.ApiOverride.sk_managedstream_set_delegates_0_Pre(parms); + } + var pRead = parms.pRead; + var pPeek = parms.pPeek; + var pIsAtEnd = parms.pIsAtEnd; + var pHasPosition = parms.pHasPosition; + var pHasLength = parms.pHasLength; + var pRewind = parms.pRewind; + var pGetPosition = parms.pGetPosition; + var pSeek = parms.pSeek; + var pMove = parms.pMove; + var pGetLength = parms.pGetLength; + var pCreateNew = parms.pCreateNew; + var pDestroy = parms.pDestroy; + var ret = CanvasKit._sk_managedstream_set_delegates(pRead, pPeek, pIsAtEnd, pHasPosition, pHasLength, pRewind, pGetPosition, pSeek, pMove, pGetLength, pCreateNew, pDestroy); + if (SkiaSharp.ApiOverride.sk_managedstream_set_delegates_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedstream_set_delegates_0_Post(ret, parms); + } + return ret; + } + static sk_managedstream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_managedstream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_managedstream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_managedstream_destroy_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_managedstream_destroy(stream); + if (SkiaSharp.ApiOverride.sk_managedstream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedstream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_managedwstream_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_managedwstream_new(); + if (SkiaSharp.ApiOverride.sk_managedwstream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedwstream_new_0_Post(ret); + } + return ret; + } + static sk_managedwstream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_managedwstream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_managedwstream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_managedwstream_destroy_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_managedwstream_destroy(stream); + if (SkiaSharp.ApiOverride.sk_managedwstream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedwstream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_managedwstream_set_delegates_0(pParams, pReturn) { + var parms = SkiaSharp.sk_managedwstream_set_delegates_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_managedwstream_set_delegates_0_Pre) { + SkiaSharp.ApiOverride.sk_managedwstream_set_delegates_0_Pre(parms); + } + var pWrite = parms.pWrite; + var pFlush = parms.pFlush; + var pBytesWritten = parms.pBytesWritten; + var pDestroy = parms.pDestroy; + var ret = CanvasKit._sk_managedwstream_set_delegates(pWrite, pFlush, pBytesWritten, pDestroy); + if (SkiaSharp.ApiOverride.sk_managedwstream_set_delegates_0_Post) { + ret = SkiaSharp.ApiOverride.sk_managedwstream_set_delegates_0_Post(ret, parms); + } + return ret; + } + static sk_filewstream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filewstream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filewstream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_filewstream_destroy_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_filewstream_destroy(cstream); + if (SkiaSharp.ApiOverride.sk_filewstream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filewstream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_dynamicmemorywstream_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_dynamicmemorywstream_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_dynamicmemorywstream_destroy_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_dynamicmemorywstream_destroy(cstream); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_filewstream_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filewstream_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filewstream_new_0_Pre) { + SkiaSharp.ApiOverride.sk_filewstream_new_0_Pre(parms); + } + var utf8path = CanvasKit._malloc(parms.utf8path_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.utf8path_Length; i++) { + CanvasKit.HEAPU8[utf8path + i] = parms.utf8path[i]; + } + } + var ret = CanvasKit._sk_filewstream_new(utf8path); + if (SkiaSharp.ApiOverride.sk_filewstream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filewstream_new_0_Post(ret, parms); + } + return ret; + } + static sk_dynamicmemorywstream_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_dynamicmemorywstream_new(); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_new_0_Post(ret); + } + return ret; + } + static sk_dynamicmemorywstream_detach_as_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_dynamicmemorywstream_detach_as_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_stream_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_dynamicmemorywstream_detach_as_stream(cstream); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_stream_0_Post(ret, parms); + } + return ret; + } + static sk_dynamicmemorywstream_detach_as_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_dynamicmemorywstream_detach_as_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_data_0_Pre) { + SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_data_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_dynamicmemorywstream_detach_as_data(cstream); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_detach_as_data_0_Post(ret, parms); + } + return ret; + } + static sk_dynamicmemorywstream_copy_to_0(pParams, pReturn) { + var parms = SkiaSharp.sk_dynamicmemorywstream_copy_to_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_copy_to_0_Pre) { + SkiaSharp.ApiOverride.sk_dynamicmemorywstream_copy_to_0_Pre(parms); + } + var cstream = parms.cstream; + var data = parms.data; + var ret = CanvasKit._sk_dynamicmemorywstream_copy_to(cstream, data); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_copy_to_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_copy_to_0_Post(ret, parms); + } + return ret; + } + static sk_dynamicmemorywstream_write_to_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_dynamicmemorywstream_write_to_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_write_to_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_dynamicmemorywstream_write_to_stream_0_Pre(parms); + } + var cstream = parms.cstream; + var dst = parms.dst; + var ret = CanvasKit._sk_dynamicmemorywstream_write_to_stream(cstream, dst); + if (SkiaSharp.ApiOverride.sk_dynamicmemorywstream_write_to_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_dynamicmemorywstream_write_to_stream_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_0_Pre(parms); + } + var cstream = parms.cstream; + var buffer = parms.buffer; + var size = parms.size; + var ret = CanvasKit._sk_wstream_write(cstream, buffer, size); + if (SkiaSharp.ApiOverride.sk_wstream_write_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_1(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_1_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_1_Pre(parms); + } + var cstream = parms.cstream; + var buffer = CanvasKit._malloc(parms.buffer_Length * 1); /*byte*/ + { + for (var i = 0; i < parms.buffer_Length; i++) { + CanvasKit.HEAPU8[buffer + i] = parms.buffer[i]; + } + } + var size = parms.size; + var ret = CanvasKit._sk_wstream_write(cstream, buffer, size); + if (SkiaSharp.ApiOverride.sk_wstream_write_1_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_1_Post(ret, parms); + } + return ret; + } + static sk_wstream_newline_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_newline_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_newline_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_newline_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_wstream_newline(cstream); + if (SkiaSharp.ApiOverride.sk_wstream_newline_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_newline_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_flush_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_flush_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_flush_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_flush_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_wstream_flush(cstream); + if (SkiaSharp.ApiOverride.sk_wstream_flush_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_flush_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_bytes_written_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_bytes_written_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_bytes_written_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_bytes_written_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_wstream_bytes_written(cstream); + if (SkiaSharp.ApiOverride.sk_wstream_bytes_written_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_bytes_written_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_8_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_8_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_8_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_8_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_8(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_8_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_8_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_16_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_16_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_16_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_16_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_16(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_16_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_16_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_32_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_32_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_32_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_32_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_32(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_32_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_32_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_text_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_text_0_Pre(parms); + } + var cstream = parms.cstream; + var value_Length = parms.value.length * 4 + 1; + var value = CanvasKit._malloc(value_Length); + CanvasKit.stringToUTF8(parms.value, value, value_Length); + var ret = CanvasKit._sk_wstream_write_text(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_text_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_dec_as_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_dec_as_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_dec_as_text_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_dec_as_text_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_dec_as_text(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_dec_as_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_dec_as_text_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_bigdec_as_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_bigdec_as_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_bigdec_as_text_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_bigdec_as_text_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var minDigits = parms.minDigits; + var ret = CanvasKit._sk_wstream_write_bigdec_as_text(cstream, value, minDigits); + if (SkiaSharp.ApiOverride.sk_wstream_write_bigdec_as_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_bigdec_as_text_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_hex_as_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_hex_as_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_hex_as_text_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_hex_as_text_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var minDigits = parms.minDigits; + var ret = CanvasKit._sk_wstream_write_hex_as_text(cstream, value, minDigits); + if (SkiaSharp.ApiOverride.sk_wstream_write_hex_as_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_hex_as_text_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_scalar_as_text_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_scalar_as_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_scalar_as_text_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_scalar_as_text_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_scalar_as_text(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_scalar_as_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_scalar_as_text_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_bool_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_bool_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_bool_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_bool_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_bool(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_bool_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_bool_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_scalar_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_scalar_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_scalar_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_scalar_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_scalar(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_scalar_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_scalar_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_packed_uint_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_packed_uint_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_packed_uint_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_packed_uint_0_Pre(parms); + } + var cstream = parms.cstream; + var value = parms.value; + var ret = CanvasKit._sk_wstream_write_packed_uint(cstream, value); + if (SkiaSharp.ApiOverride.sk_wstream_write_packed_uint_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_packed_uint_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_write_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_write_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_write_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_write_stream_0_Pre(parms); + } + var cstream = parms.cstream; + var input = parms.input; + var length = parms.length; + var ret = CanvasKit._sk_wstream_write_stream(cstream, input, length); + if (SkiaSharp.ApiOverride.sk_wstream_write_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_write_stream_0_Post(ret, parms); + } + return ret; + } + static sk_wstream_get_size_of_packed_uint_0(pParams, pReturn) { + var parms = SkiaSharp.sk_wstream_get_size_of_packed_uint_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_wstream_get_size_of_packed_uint_0_Pre) { + SkiaSharp.ApiOverride.sk_wstream_get_size_of_packed_uint_0_Pre(parms); + } + var value = parms.value; + var ret = CanvasKit._sk_wstream_get_size_of_packed_uint(value); + if (SkiaSharp.ApiOverride.sk_wstream_get_size_of_packed_uint_0_Post) { + ret = SkiaSharp.ApiOverride.sk_wstream_get_size_of_packed_uint_0_Post(ret, parms); + } + return ret; + } + static sk_filewstream_is_valid_0(pParams, pReturn) { + var parms = SkiaSharp.sk_filewstream_is_valid_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_filewstream_is_valid_0_Pre) { + SkiaSharp.ApiOverride.sk_filewstream_is_valid_0_Pre(parms); + } + var cstream = parms.cstream; + var ret = CanvasKit._sk_filewstream_is_valid(cstream); + if (SkiaSharp.ApiOverride.sk_filewstream_is_valid_0_Post) { + ret = SkiaSharp.ApiOverride.sk_filewstream_is_valid_0_Post(ret, parms); + } + return ret; + } + static sk_document_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_document_unref_0_Pre(parms); + } + var document = parms.document; + var ret = CanvasKit._sk_document_unref(document); + if (SkiaSharp.ApiOverride.sk_document_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_unref_0_Post(ret, parms); + } + return ret; + } + static sk_document_create_pdf_from_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_create_pdf_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_document_create_pdf_from_stream(stream); + if (SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_0_Post(ret, parms); + } + return ret; + } + static sk_document_create_pdf_from_stream_with_metadata_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_document_create_pdf_from_stream_with_metadata_0_Return(); + var parms = SkiaSharp.sk_document_create_pdf_from_stream_with_metadata_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_with_metadata_0_Pre) { + SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_with_metadata_0_Pre(parms); + } + var stream = parms.stream; + var metadata = parms.metadata.marshalNew(CanvasKit); + var ret = CanvasKit._sk_document_create_pdf_from_stream_with_metadata(stream, metadata); + var retStruct = new SkiaSharp.sk_document_create_pdf_from_stream_with_metadata_0_Return(); + retStruct.metadata = SkiaSharp.SKDocumentPdfMetadataInternal.unmarshal(metadata, CanvasKit); + if (SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_with_metadata_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_create_pdf_from_stream_with_metadata_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_document_create_xps_from_stream_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_create_xps_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_create_xps_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_document_create_xps_from_stream_0_Pre(parms); + } + var stream = parms.stream; + var dpi = parms.dpi; + var ret = CanvasKit._sk_document_create_xps_from_stream(stream, dpi); + if (SkiaSharp.ApiOverride.sk_document_create_xps_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_create_xps_from_stream_0_Post(ret, parms); + } + return ret; + } + static sk_document_begin_page_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_document_begin_page_0_Return(); + var parms = SkiaSharp.sk_document_begin_page_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_begin_page_0_Pre) { + SkiaSharp.ApiOverride.sk_document_begin_page_0_Pre(parms); + } + var document = parms.document; + var width = parms.width; + var height = parms.height; + var content = parms.content.marshalNew(CanvasKit); + var ret = CanvasKit._sk_document_begin_page(document, width, height, content); + var retStruct = new SkiaSharp.sk_document_begin_page_0_Return(); + retStruct.content = SkiaSharp.SKRect.unmarshal(content, CanvasKit); + if (SkiaSharp.ApiOverride.sk_document_begin_page_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_begin_page_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_document_begin_page_1(pParams, pReturn) { + var parms = SkiaSharp.sk_document_begin_page_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_begin_page_1_Pre) { + SkiaSharp.ApiOverride.sk_document_begin_page_1_Pre(parms); + } + var document = parms.document; + var width = parms.width; + var height = parms.height; + var contentZero = parms.contentZero; + var ret = CanvasKit._sk_document_begin_page(document, width, height, contentZero); + if (SkiaSharp.ApiOverride.sk_document_begin_page_1_Post) { + ret = SkiaSharp.ApiOverride.sk_document_begin_page_1_Post(ret, parms); + } + return ret; + } + static sk_document_end_page_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_end_page_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_end_page_0_Pre) { + SkiaSharp.ApiOverride.sk_document_end_page_0_Pre(parms); + } + var document = parms.document; + var ret = CanvasKit._sk_document_end_page(document); + if (SkiaSharp.ApiOverride.sk_document_end_page_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_end_page_0_Post(ret, parms); + } + return ret; + } + static sk_document_close_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_close_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_close_0_Pre) { + SkiaSharp.ApiOverride.sk_document_close_0_Pre(parms); + } + var document = parms.document; + var ret = CanvasKit._sk_document_close(document); + if (SkiaSharp.ApiOverride.sk_document_close_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_close_0_Post(ret, parms); + } + return ret; + } + static sk_document_abort_0(pParams, pReturn) { + var parms = SkiaSharp.sk_document_abort_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_document_abort_0_Pre) { + SkiaSharp.ApiOverride.sk_document_abort_0_Pre(parms); + } + var document = parms.document; + var ret = CanvasKit._sk_document_abort(document); + if (SkiaSharp.ApiOverride.sk_document_abort_0_Post) { + ret = SkiaSharp.ApiOverride.sk_document_abort_0_Post(ret, parms); + } + return ret; + } + static sk_codec_min_buffered_bytes_needed_0(pParams, pReturn) { + var ret = CanvasKit._sk_codec_min_buffered_bytes_needed(); + if (SkiaSharp.ApiOverride.sk_codec_min_buffered_bytes_needed_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_min_buffered_bytes_needed_0_Post(ret); + } + return ret; + } + static sk_codec_new_from_stream_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_new_from_stream_0_Return(); + var parms = SkiaSharp.sk_codec_new_from_stream_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_new_from_stream_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_new_from_stream_0_Pre(parms); + } + var stream = parms.stream; + var result = CanvasKit._malloc(4); + var ret = CanvasKit._sk_codec_new_from_stream(stream, result); + var retStruct = new SkiaSharp.sk_codec_new_from_stream_0_Return(); + retStruct.result = CanvasKit.getValue(result, "i32"); + if (SkiaSharp.ApiOverride.sk_codec_new_from_stream_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_new_from_stream_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_new_from_data_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_new_from_data_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_new_from_data_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_new_from_data_0_Pre(parms); + } + var data = parms.data; + var ret = CanvasKit._sk_codec_new_from_data(data); + if (SkiaSharp.ApiOverride.sk_codec_new_from_data_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_new_from_data_0_Post(ret, parms); + } + return ret; + } + static sk_codec_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_destroy_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_destroy(codec); + if (SkiaSharp.ApiOverride.sk_codec_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_info_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_get_info_0_Return(); + var parms = SkiaSharp.sk_codec_get_info_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_info_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_info_0_Pre(parms); + } + var codec = parms.codec; + var info = retStruct.info.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_get_info(codec, info); + var retStruct = new SkiaSharp.sk_codec_get_info_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_get_info_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_info_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_get_origin_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_origin_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_origin_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_origin_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_get_origin(codec); + if (SkiaSharp.ApiOverride.sk_codec_get_origin_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_origin_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_scaled_dimensions_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_get_scaled_dimensions_0_Return(); + var parms = SkiaSharp.sk_codec_get_scaled_dimensions_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_scaled_dimensions_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_scaled_dimensions_0_Pre(parms); + } + var codec = parms.codec; + var desiredScale = parms.desiredScale; + var dimensions = retStruct.dimensions.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_get_scaled_dimensions(codec, desiredScale, dimensions); + var retStruct = new SkiaSharp.sk_codec_get_scaled_dimensions_0_Return(); + retStruct.dimensions = SkiaSharp.SKSizeI.unmarshal(dimensions, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_get_scaled_dimensions_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_scaled_dimensions_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_get_valid_subset_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_get_valid_subset_0_Return(); + var parms = SkiaSharp.sk_codec_get_valid_subset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_valid_subset_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_valid_subset_0_Pre(parms); + } + var codec = parms.codec; + var desiredSubset = parms.desiredSubset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_get_valid_subset(codec, desiredSubset); + var retStruct = new SkiaSharp.sk_codec_get_valid_subset_0_Return(); + retStruct.desiredSubset = SkiaSharp.SKRectI.unmarshal(desiredSubset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_get_valid_subset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_valid_subset_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_get_encoded_format_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_encoded_format_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_encoded_format_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_encoded_format_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_get_encoded_format(codec); + if (SkiaSharp.ApiOverride.sk_codec_get_encoded_format_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_encoded_format_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_get_pixels_0_Return(); + var parms = SkiaSharp.sk_codec_get_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_pixels_0_Pre(parms); + } + var codec = parms.codec; + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_get_pixels(codec, info, pixels, rowBytes, options); + var retStruct = new SkiaSharp.sk_codec_get_pixels_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + retStruct.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(options, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_get_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_start_incremental_decode_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_start_incremental_decode_0_Return(); + var parms = SkiaSharp.sk_codec_start_incremental_decode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_0_Pre(parms); + } + var codec = parms.codec; + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_start_incremental_decode(codec, info, pixels, rowBytes, options); + var retStruct = new SkiaSharp.sk_codec_start_incremental_decode_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + retStruct.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(options, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_start_incremental_decode_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_start_incremental_decode_1_Return(); + var parms = SkiaSharp.sk_codec_start_incremental_decode_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_1_Pre) { + SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_1_Pre(parms); + } + var codec = parms.codec; + var info = parms.info.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var optionsZero = parms.optionsZero; + var ret = CanvasKit._sk_codec_start_incremental_decode(codec, info, pixels, rowBytes, optionsZero); + var retStruct = new SkiaSharp.sk_codec_start_incremental_decode_1_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_1_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_start_incremental_decode_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_incremental_decode_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_incremental_decode_0_Return(); + var parms = SkiaSharp.sk_codec_incremental_decode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_incremental_decode_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_incremental_decode_0_Pre(parms); + } + var codec = parms.codec; + var rowsDecoded = CanvasKit._malloc(4); + var ret = CanvasKit._sk_codec_incremental_decode(codec, rowsDecoded); + var retStruct = new SkiaSharp.sk_codec_incremental_decode_0_Return(); + retStruct.rowsDecoded = CanvasKit.getValue(rowsDecoded, "i32"); + if (SkiaSharp.ApiOverride.sk_codec_incremental_decode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_incremental_decode_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_get_repetition_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_repetition_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_repetition_count_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_repetition_count_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_get_repetition_count(codec); + if (SkiaSharp.ApiOverride.sk_codec_get_repetition_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_repetition_count_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_frame_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_frame_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_count_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_frame_count_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_get_frame_count(codec); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_frame_count_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_frame_info_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_frame_info_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_info_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_frame_info_0_Pre(parms); + } + var codec = parms.codec; + var frameInfo = parms.frameInfo; + var ret = CanvasKit._sk_codec_get_frame_info(codec, frameInfo); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_info_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_frame_info_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_frame_info_for_index_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_get_frame_info_for_index_0_Return(); + var parms = SkiaSharp.sk_codec_get_frame_info_for_index_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_info_for_index_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_frame_info_for_index_0_Pre(parms); + } + var codec = parms.codec; + var index = parms.index; + var frameInfo = retStruct.frameInfo.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_get_frame_info_for_index(codec, index, frameInfo); + var retStruct = new SkiaSharp.sk_codec_get_frame_info_for_index_0_Return(); + retStruct.frameInfo = SkiaSharp.SKCodecFrameInfo.unmarshal(frameInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_get_frame_info_for_index_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_frame_info_for_index_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_start_scanline_decode_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_start_scanline_decode_0_Return(); + var parms = SkiaSharp.sk_codec_start_scanline_decode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_0_Pre(parms); + } + var codec = parms.codec; + var info = parms.info.marshalNew(CanvasKit); + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_codec_start_scanline_decode(codec, info, options); + var retStruct = new SkiaSharp.sk_codec_start_scanline_decode_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + retStruct.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(options, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_start_scanline_decode_1(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_codec_start_scanline_decode_1_Return(); + var parms = SkiaSharp.sk_codec_start_scanline_decode_1_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_1_Pre) { + SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_1_Pre(parms); + } + var codec = parms.codec; + var info = parms.info.marshalNew(CanvasKit); + var optionsZero = parms.optionsZero; + var ret = CanvasKit._sk_codec_start_scanline_decode(codec, info, optionsZero); + var retStruct = new SkiaSharp.sk_codec_start_scanline_decode_1_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_1_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_start_scanline_decode_1_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_codec_get_scanlines_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_scanlines_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_scanlines_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_scanlines_0_Pre(parms); + } + var codec = parms.codec; + var dst = parms.dst; + var countLines = parms.countLines; + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_codec_get_scanlines(codec, dst, countLines, rowBytes); + if (SkiaSharp.ApiOverride.sk_codec_get_scanlines_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_scanlines_0_Post(ret, parms); + } + return ret; + } + static sk_codec_skip_scanlines_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_skip_scanlines_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_skip_scanlines_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_skip_scanlines_0_Pre(parms); + } + var codec = parms.codec; + var countLines = parms.countLines; + var ret = CanvasKit._sk_codec_skip_scanlines(codec, countLines); + if (SkiaSharp.ApiOverride.sk_codec_skip_scanlines_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_skip_scanlines_0_Post(ret, parms); + } + return ret; + } + static sk_codec_get_scanline_order_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_get_scanline_order_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_get_scanline_order_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_get_scanline_order_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_get_scanline_order(codec); + if (SkiaSharp.ApiOverride.sk_codec_get_scanline_order_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_get_scanline_order_0_Post(ret, parms); + } + return ret; + } + static sk_codec_next_scanline_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_next_scanline_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_next_scanline_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_next_scanline_0_Pre(parms); + } + var codec = parms.codec; + var ret = CanvasKit._sk_codec_next_scanline(codec); + if (SkiaSharp.ApiOverride.sk_codec_next_scanline_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_next_scanline_0_Post(ret, parms); + } + return ret; + } + static sk_codec_output_scanline_0(pParams, pReturn) { + var parms = SkiaSharp.sk_codec_output_scanline_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_codec_output_scanline_0_Pre) { + SkiaSharp.ApiOverride.sk_codec_output_scanline_0_Pre(parms); + } + var codec = parms.codec; + var inputScanline = parms.inputScanline; + var ret = CanvasKit._sk_codec_output_scanline(codec, inputScanline); + if (SkiaSharp.ApiOverride.sk_codec_output_scanline_0_Post) { + ret = SkiaSharp.ApiOverride.sk_codec_output_scanline_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_bitmap_new(); + if (SkiaSharp.ApiOverride.sk_bitmap_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_new_0_Post(ret); + } + return ret; + } + static sk_bitmap_destructor_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_destructor_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_destructor_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_destructor_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_destructor(b); + if (SkiaSharp.ApiOverride.sk_bitmap_destructor_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_destructor_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_info_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_get_info_0_Return(); + var parms = SkiaSharp.sk_bitmap_get_info_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_info_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_info_0_Pre(parms); + } + var b = parms.b; + var info = retStruct.info.marshalNew(CanvasKit); + var ret = CanvasKit._sk_bitmap_get_info(b, info); + var retStruct = new SkiaSharp.sk_bitmap_get_info_0_Return(); + retStruct.info = SkiaSharp.SKImageInfoNative.unmarshal(info, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_get_info_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_info_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_get_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_get_pixels_0_Return(); + var parms = SkiaSharp.sk_bitmap_get_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_pixels_0_Pre(parms); + } + var b = parms.b; + var length = CanvasKit._malloc(4); + var ret = CanvasKit._sk_bitmap_get_pixels(b, length); + var retStruct = new SkiaSharp.sk_bitmap_get_pixels_0_Return(); + retStruct.length = CanvasKit.getValue(length, "i32"); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_get_pixel_colors_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_pixel_colors_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixel_colors_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_pixel_colors_0_Pre(parms); + } + var b = parms.b; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var ret = CanvasKit._sk_bitmap_get_pixel_colors(b, colors); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixel_colors_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_pixel_colors_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_set_pixel_colors_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_set_pixel_colors_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixel_colors_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_set_pixel_colors_0_Pre(parms); + } + var b = parms.b; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var ret = CanvasKit._sk_bitmap_set_pixel_colors(b, colors); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixel_colors_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_set_pixel_colors_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_reset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_reset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_reset_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_reset_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_reset(b); + if (SkiaSharp.ApiOverride.sk_bitmap_reset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_reset_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_row_bytes_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_row_bytes_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_row_bytes_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_row_bytes_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_get_row_bytes(b); + if (SkiaSharp.ApiOverride.sk_bitmap_get_row_bytes_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_row_bytes_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_byte_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_byte_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_byte_count_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_byte_count_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_get_byte_count(b); + if (SkiaSharp.ApiOverride.sk_bitmap_get_byte_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_byte_count_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_is_null_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_is_null_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_is_null_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_is_null_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_is_null(b); + if (SkiaSharp.ApiOverride.sk_bitmap_is_null_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_is_null_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_is_immutable_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_is_immutable_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_is_immutable_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_is_immutable_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_is_immutable(b); + if (SkiaSharp.ApiOverride.sk_bitmap_is_immutable_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_is_immutable_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_set_immutable_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_set_immutable_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_set_immutable_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_set_immutable_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_set_immutable(b); + if (SkiaSharp.ApiOverride.sk_bitmap_set_immutable_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_set_immutable_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_is_volatile_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_is_volatile_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_is_volatile_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_is_volatile_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_is_volatile(b); + if (SkiaSharp.ApiOverride.sk_bitmap_is_volatile_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_is_volatile_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_set_volatile_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_set_volatile_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_set_volatile_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_set_volatile_0_Pre(parms); + } + var b = parms.b; + var value = parms.value; + var ret = CanvasKit._sk_bitmap_set_volatile(b, value); + if (SkiaSharp.ApiOverride.sk_bitmap_set_volatile_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_set_volatile_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_erase_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_erase_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_erase_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_erase_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var color = parms.color.color; + var ret = CanvasKit._sk_bitmap_erase(cbitmap, color); + if (SkiaSharp.ApiOverride.sk_bitmap_erase_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_erase_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_erase_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_erase_rect_0_Return(); + var parms = SkiaSharp.sk_bitmap_erase_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_erase_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_erase_rect_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var color = parms.color.color; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_bitmap_erase_rect(cbitmap, color, rect); + var retStruct = new SkiaSharp.sk_bitmap_erase_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRectI.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_erase_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_erase_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_get_addr_8_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_addr_8_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_8_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_addr_8_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_bitmap_get_addr_8(cbitmap, x, y); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_8_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_addr_8_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_addr_16_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_addr_16_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_16_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_addr_16_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_bitmap_get_addr_16(cbitmap, x, y); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_16_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_addr_16_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_addr_32_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_addr_32_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_32_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_addr_32_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_bitmap_get_addr_32(cbitmap, x, y); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_32_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_addr_32_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_addr_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_addr_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_addr_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_bitmap_get_addr(cbitmap, x, y); + if (SkiaSharp.ApiOverride.sk_bitmap_get_addr_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_addr_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_get_pixel_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_get_pixel_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixel_color_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_get_pixel_color_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_bitmap_get_pixel_color(cbitmap, x, y); + if (SkiaSharp.ApiOverride.sk_bitmap_get_pixel_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_get_pixel_color_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_set_pixel_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_set_pixel_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixel_color_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_set_pixel_color_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var x = parms.x; + var y = parms.y; + var color = parms.color.color; + var ret = CanvasKit._sk_bitmap_set_pixel_color(cbitmap, x, y, color); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixel_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_set_pixel_color_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_ready_to_draw_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_ready_to_draw_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_ready_to_draw_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_ready_to_draw_0_Pre(parms); + } + var b = parms.b; + var ret = CanvasKit._sk_bitmap_ready_to_draw(b); + if (SkiaSharp.ApiOverride.sk_bitmap_ready_to_draw_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_ready_to_draw_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_install_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_install_pixels_0_Return(); + var parms = SkiaSharp.sk_bitmap_install_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_install_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_install_pixels_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cinfo = parms.cinfo.marshalNew(CanvasKit); + var pixels = parms.pixels; + var rowBytes = parms.rowBytes; + var releaseProc = parms.releaseProc; + var context = parms.context; + var ret = CanvasKit._sk_bitmap_install_pixels(cbitmap, cinfo, pixels, rowBytes, releaseProc, context); + var retStruct = new SkiaSharp.sk_bitmap_install_pixels_0_Return(); + retStruct.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(cinfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_install_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_install_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_install_pixels_with_pixmap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_install_pixels_with_pixmap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_install_pixels_with_pixmap_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_install_pixels_with_pixmap_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_bitmap_install_pixels_with_pixmap(cbitmap, cpixmap); + if (SkiaSharp.ApiOverride.sk_bitmap_install_pixels_with_pixmap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_install_pixels_with_pixmap_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_install_mask_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_install_mask_pixels_0_Return(); + var parms = SkiaSharp.sk_bitmap_install_mask_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_install_mask_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_install_mask_pixels_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cmask = parms.cmask.marshalNew(CanvasKit); + var ret = CanvasKit._sk_bitmap_install_mask_pixels(cbitmap, cmask); + var retStruct = new SkiaSharp.sk_bitmap_install_mask_pixels_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_install_mask_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_install_mask_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_try_alloc_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_try_alloc_pixels_0_Return(); + var parms = SkiaSharp.sk_bitmap_try_alloc_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var requestedInfo = parms.requestedInfo.marshalNew(CanvasKit); + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_bitmap_try_alloc_pixels(cbitmap, requestedInfo, rowBytes); + var retStruct = new SkiaSharp.sk_bitmap_try_alloc_pixels_0_Return(); + retStruct.requestedInfo = SkiaSharp.SKImageInfoNative.unmarshal(requestedInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_try_alloc_pixels_with_flags_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_try_alloc_pixels_with_flags_0_Return(); + var parms = SkiaSharp.sk_bitmap_try_alloc_pixels_with_flags_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_with_flags_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_with_flags_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var requestedInfo = parms.requestedInfo.marshalNew(CanvasKit); + var flags = parms.flags; + var ret = CanvasKit._sk_bitmap_try_alloc_pixels_with_flags(cbitmap, requestedInfo, flags); + var retStruct = new SkiaSharp.sk_bitmap_try_alloc_pixels_with_flags_0_Return(); + retStruct.requestedInfo = SkiaSharp.SKImageInfoNative.unmarshal(requestedInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_with_flags_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_try_alloc_pixels_with_flags_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_set_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_set_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_set_pixels_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var pixels = parms.pixels; + var ret = CanvasKit._sk_bitmap_set_pixels(cbitmap, pixels); + if (SkiaSharp.ApiOverride.sk_bitmap_set_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_set_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_peek_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_peek_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_peek_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_peek_pixels_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_bitmap_peek_pixels(cbitmap, cpixmap); + if (SkiaSharp.ApiOverride.sk_bitmap_peek_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_peek_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_extract_subset_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_extract_subset_0_Return(); + var parms = SkiaSharp.sk_bitmap_extract_subset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_extract_subset_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_extract_subset_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cdst = parms.cdst; + var subset = parms.subset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_bitmap_extract_subset(cbitmap, cdst, subset); + var retStruct = new SkiaSharp.sk_bitmap_extract_subset_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_extract_subset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_extract_subset_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_extract_alpha_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_bitmap_extract_alpha_0_Return(); + var parms = SkiaSharp.sk_bitmap_extract_alpha_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_extract_alpha_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_extract_alpha_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var dst = parms.dst; + var paint = parms.paint; + var offset = retStruct.offset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_bitmap_extract_alpha(cbitmap, dst, paint, offset); + var retStruct = new SkiaSharp.sk_bitmap_extract_alpha_0_Return(); + retStruct.offset = SkiaSharp.SKPointI.unmarshal(offset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_bitmap_extract_alpha_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_extract_alpha_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_bitmap_notify_pixels_changed_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_notify_pixels_changed_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_notify_pixels_changed_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_notify_pixels_changed_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var ret = CanvasKit._sk_bitmap_notify_pixels_changed(cbitmap); + if (SkiaSharp.ApiOverride.sk_bitmap_notify_pixels_changed_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_notify_pixels_changed_0_Post(ret, parms); + } + return ret; + } + static sk_bitmap_swap_0(pParams, pReturn) { + var parms = SkiaSharp.sk_bitmap_swap_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_bitmap_swap_0_Pre) { + SkiaSharp.ApiOverride.sk_bitmap_swap_0_Pre(parms); + } + var cbitmap = parms.cbitmap; + var cother = parms.cother; + var ret = CanvasKit._sk_bitmap_swap(cbitmap, cother); + if (SkiaSharp.ApiOverride.sk_bitmap_swap_0_Post) { + ret = SkiaSharp.ApiOverride.sk_bitmap_swap_0_Post(ret, parms); + } + return ret; + } + static sk_color_unpremultiply_0(pParams, pReturn) { + var parms = SkiaSharp.sk_color_unpremultiply_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_color_unpremultiply_0_Pre) { + SkiaSharp.ApiOverride.sk_color_unpremultiply_0_Pre(parms); + } + var pmcolor = parms.pmcolor.marshalNew(CanvasKit); + var ret = CanvasKit._sk_color_unpremultiply(pmcolor); + if (SkiaSharp.ApiOverride.sk_color_unpremultiply_0_Post) { + ret = SkiaSharp.ApiOverride.sk_color_unpremultiply_0_Post(ret, parms); + } + return ret; + } + static sk_color_premultiply_0(pParams, pReturn) { + var parms = SkiaSharp.sk_color_premultiply_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_color_premultiply_0_Pre) { + SkiaSharp.ApiOverride.sk_color_premultiply_0_Pre(parms); + } + var color = parms.color.color; + var ret = CanvasKit._sk_color_premultiply(color); + if (SkiaSharp.ApiOverride.sk_color_premultiply_0_Post) { + ret = SkiaSharp.ApiOverride.sk_color_premultiply_0_Post(ret, parms); + } + return ret; + } + static sk_color_unpremultiply_array_0(pParams, pReturn) { + var parms = SkiaSharp.sk_color_unpremultiply_array_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_color_unpremultiply_array_0_Pre) { + SkiaSharp.ApiOverride.sk_color_unpremultiply_array_0_Pre(parms); + } + var pmcolors = parms.pmcolors; + var size = parms.size; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var ret = CanvasKit._sk_color_unpremultiply_array(pmcolors, size, colors); + if (SkiaSharp.ApiOverride.sk_color_unpremultiply_array_0_Post) { + ret = SkiaSharp.ApiOverride.sk_color_unpremultiply_array_0_Post(ret, parms); + } + return ret; + } + static sk_color_premultiply_array_0(pParams, pReturn) { + var parms = SkiaSharp.sk_color_premultiply_array_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_color_premultiply_array_0_Pre) { + SkiaSharp.ApiOverride.sk_color_premultiply_array_0_Pre(parms); + } + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var size = parms.size; + var pmcolors = parms.pmcolors; + var ret = CanvasKit._sk_color_premultiply_array(colors, size, pmcolors); + if (SkiaSharp.ApiOverride.sk_color_premultiply_array_0_Post) { + ret = SkiaSharp.ApiOverride.sk_color_premultiply_array_0_Post(ret, parms); + } + return ret; + } + static sk_color_get_bit_shift_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_color_get_bit_shift_0_Return(); + var parms = SkiaSharp.sk_color_get_bit_shift_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_color_get_bit_shift_0_Pre) { + SkiaSharp.ApiOverride.sk_color_get_bit_shift_0_Pre(parms); + } + var a = CanvasKit._malloc(4); + var r = CanvasKit._malloc(4); + var g = CanvasKit._malloc(4); + var b = CanvasKit._malloc(4); + var ret = CanvasKit._sk_color_get_bit_shift(a, r, g, b); + var retStruct = new SkiaSharp.sk_color_get_bit_shift_0_Return(); + retStruct.a = CanvasKit.getValue(a, "i32"); + retStruct.r = CanvasKit.getValue(r, "i32"); + retStruct.g = CanvasKit.getValue(g, "i32"); + retStruct.b = CanvasKit.getValue(b, "i32"); + if (SkiaSharp.ApiOverride.sk_color_get_bit_shift_0_Post) { + ret = SkiaSharp.ApiOverride.sk_color_get_bit_shift_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_destructor_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_destructor_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_destructor_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_destructor_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_pixmap_destructor(cpixmap); + if (SkiaSharp.ApiOverride.sk_pixmap_destructor_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_destructor_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_pixmap_new(); + if (SkiaSharp.ApiOverride.sk_pixmap_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_new_0_Post(ret); + } + return ret; + } + static sk_pixmap_new_with_params_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_new_with_params_0_Return(); + var parms = SkiaSharp.sk_pixmap_new_with_params_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_new_with_params_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_new_with_params_0_Pre(parms); + } + var cinfo = parms.cinfo.marshalNew(CanvasKit); + var addr = parms.addr; + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_pixmap_new_with_params(cinfo, addr, rowBytes); + var retStruct = new SkiaSharp.sk_pixmap_new_with_params_0_Return(); + retStruct.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(cinfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_new_with_params_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_new_with_params_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_reset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_reset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_reset_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_reset_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_pixmap_reset(cpixmap); + if (SkiaSharp.ApiOverride.sk_pixmap_reset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_reset_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_reset_with_params_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_reset_with_params_0_Return(); + var parms = SkiaSharp.sk_pixmap_reset_with_params_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_reset_with_params_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_reset_with_params_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var cinfo = parms.cinfo.marshalNew(CanvasKit); + var addr = parms.addr; + var rowBytes = parms.rowBytes; + var ret = CanvasKit._sk_pixmap_reset_with_params(cpixmap, cinfo, addr, rowBytes); + var retStruct = new SkiaSharp.sk_pixmap_reset_with_params_0_Return(); + retStruct.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(cinfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_reset_with_params_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_reset_with_params_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_get_info_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_get_info_0_Return(); + var parms = SkiaSharp.sk_pixmap_get_info_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_get_info_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_get_info_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var cinfo = retStruct.cinfo.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pixmap_get_info(cpixmap, cinfo); + var retStruct = new SkiaSharp.sk_pixmap_get_info_0_Return(); + retStruct.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(cinfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_get_info_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_get_info_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_get_row_bytes_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_get_row_bytes_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_get_row_bytes_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_get_row_bytes_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_pixmap_get_row_bytes(cpixmap); + if (SkiaSharp.ApiOverride.sk_pixmap_get_row_bytes_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_get_row_bytes_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_get_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_get_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_get_pixels_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var ret = CanvasKit._sk_pixmap_get_pixels(cpixmap); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_get_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_get_pixels_with_xy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_get_pixels_with_xy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixels_with_xy_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_get_pixels_with_xy_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_pixmap_get_pixels_with_xy(cpixmap, x, y); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixels_with_xy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_get_pixels_with_xy_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_get_pixel_color_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_get_pixel_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixel_color_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_get_pixel_color_0_Pre(parms); + } + var t = parms.t; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_pixmap_get_pixel_color(t, x, y); + if (SkiaSharp.ApiOverride.sk_pixmap_get_pixel_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_get_pixel_color_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_extract_subset_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_extract_subset_0_Return(); + var parms = SkiaSharp.sk_pixmap_extract_subset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_extract_subset_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_extract_subset_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var result = parms.result; + var subset = parms.subset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pixmap_extract_subset(cpixmap, result, subset); + var retStruct = new SkiaSharp.sk_pixmap_extract_subset_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_extract_subset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_extract_subset_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_erase_color_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_erase_color_0_Return(); + var parms = SkiaSharp.sk_pixmap_erase_color_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_erase_color_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_erase_color_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var color = parms.color.color; + var subset = parms.subset.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pixmap_erase_color(cpixmap, color, subset); + var retStruct = new SkiaSharp.sk_pixmap_erase_color_0_Return(); + retStruct.subset = SkiaSharp.SKRectI.unmarshal(subset, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_erase_color_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_erase_color_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_encode_image_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_encode_image_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_encode_image_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_encode_image_0_Pre(parms); + } + var dst = parms.dst; + var src = parms.src; + var encoder = parms.encoder; + var quality = parms.quality; + var ret = CanvasKit._sk_pixmap_encode_image(dst, src, encoder, quality); + if (SkiaSharp.ApiOverride.sk_pixmap_encode_image_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_encode_image_0_Post(ret, parms); + } + return ret; + } + static sk_pixmap_read_pixels_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_pixmap_read_pixels_0_Return(); + var parms = SkiaSharp.sk_pixmap_read_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_read_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_read_pixels_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var dstInfo = parms.dstInfo.marshalNew(CanvasKit); + var dstPixels = parms.dstPixels; + var dstRowBytes = parms.dstRowBytes; + var srcX = parms.srcX; + var srcY = parms.srcY; + var behavior = parms.behavior; + var ret = CanvasKit._sk_pixmap_read_pixels(cpixmap, dstInfo, dstPixels, dstRowBytes, srcX, srcY, behavior); + var retStruct = new SkiaSharp.sk_pixmap_read_pixels_0_Return(); + retStruct.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(dstInfo, CanvasKit); + if (SkiaSharp.ApiOverride.sk_pixmap_read_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_read_pixels_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_pixmap_scale_pixels_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pixmap_scale_pixels_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pixmap_scale_pixels_0_Pre) { + SkiaSharp.ApiOverride.sk_pixmap_scale_pixels_0_Pre(parms); + } + var cpixmap = parms.cpixmap; + var dst = parms.dst; + var quality = parms.quality; + var ret = CanvasKit._sk_pixmap_scale_pixels(cpixmap, dst, quality); + if (SkiaSharp.ApiOverride.sk_pixmap_scale_pixels_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pixmap_scale_pixels_0_Post(ret, parms); + } + return ret; + } + static sk_swizzle_swap_rb_0(pParams, pReturn) { + var parms = SkiaSharp.sk_swizzle_swap_rb_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_swizzle_swap_rb_0_Pre) { + SkiaSharp.ApiOverride.sk_swizzle_swap_rb_0_Pre(parms); + } + var dest = parms.dest; + var src = parms.src; + var count = parms.count; + var ret = CanvasKit._sk_swizzle_swap_rb(dest, src, count); + if (SkiaSharp.ApiOverride.sk_swizzle_swap_rb_0_Post) { + ret = SkiaSharp.ApiOverride.sk_swizzle_swap_rb_0_Post(ret, parms); + } + return ret; + } + static sk_webpencoder_encode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_webpencoder_encode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_webpencoder_encode_0_Pre) { + SkiaSharp.ApiOverride.sk_webpencoder_encode_0_Pre(parms); + } + var dst = parms.dst; + var src = parms.src; + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_webpencoder_encode(dst, src, options); + if (SkiaSharp.ApiOverride.sk_webpencoder_encode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_webpencoder_encode_0_Post(ret, parms); + } + return ret; + } + static sk_jpegencoder_encode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_jpegencoder_encode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_jpegencoder_encode_0_Pre) { + SkiaSharp.ApiOverride.sk_jpegencoder_encode_0_Pre(parms); + } + var dst = parms.dst; + var src = parms.src; + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_jpegencoder_encode(dst, src, options); + if (SkiaSharp.ApiOverride.sk_jpegencoder_encode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_jpegencoder_encode_0_Post(ret, parms); + } + return ret; + } + static sk_pngencoder_encode_0(pParams, pReturn) { + var parms = SkiaSharp.sk_pngencoder_encode_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_pngencoder_encode_0_Pre) { + SkiaSharp.ApiOverride.sk_pngencoder_encode_0_Pre(parms); + } + var dst = parms.dst; + var src = parms.src; + var options = parms.options.marshalNew(CanvasKit); + var ret = CanvasKit._sk_pngencoder_encode(dst, src, options); + if (SkiaSharp.ApiOverride.sk_pngencoder_encode_0_Post) { + ret = SkiaSharp.ApiOverride.sk_pngencoder_encode_0_Post(ret, parms); + } + return ret; + } + static sk_mask_alloc_image_0(pParams, pReturn) { + var parms = SkiaSharp.sk_mask_alloc_image_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_alloc_image_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_alloc_image_0_Pre(parms); + } + var bytes = parms.bytes; + var ret = CanvasKit._sk_mask_alloc_image(bytes); + if (SkiaSharp.ApiOverride.sk_mask_alloc_image_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_alloc_image_0_Post(ret, parms); + } + return ret; + } + static sk_mask_free_image_0(pParams, pReturn) { + var parms = SkiaSharp.sk_mask_free_image_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_free_image_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_free_image_0_Pre(parms); + } + var image = parms.image; + var ret = CanvasKit._sk_mask_free_image(image); + if (SkiaSharp.ApiOverride.sk_mask_free_image_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_free_image_0_Post(ret, parms); + } + return ret; + } + static sk_mask_is_empty_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_is_empty_0_Return(); + var parms = SkiaSharp.sk_mask_is_empty_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_is_empty_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_is_empty_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var ret = CanvasKit._sk_mask_is_empty(cmask); + var retStruct = new SkiaSharp.sk_mask_is_empty_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_is_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_is_empty_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_compute_image_size_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_compute_image_size_0_Return(); + var parms = SkiaSharp.sk_mask_compute_image_size_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_compute_image_size_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_compute_image_size_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var ret = CanvasKit._sk_mask_compute_image_size(cmask); + var retStruct = new SkiaSharp.sk_mask_compute_image_size_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_compute_image_size_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_compute_image_size_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_compute_total_image_size_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_compute_total_image_size_0_Return(); + var parms = SkiaSharp.sk_mask_compute_total_image_size_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_compute_total_image_size_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_compute_total_image_size_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var ret = CanvasKit._sk_mask_compute_total_image_size(cmask); + var retStruct = new SkiaSharp.sk_mask_compute_total_image_size_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_compute_total_image_size_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_compute_total_image_size_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_get_addr_1_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_get_addr_1_0_Return(); + var parms = SkiaSharp.sk_mask_get_addr_1_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_1_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_get_addr_1_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_mask_get_addr_1(cmask, x, y); + var retStruct = new SkiaSharp.sk_mask_get_addr_1_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_1_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_get_addr_1_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_get_addr_8_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_get_addr_8_0_Return(); + var parms = SkiaSharp.sk_mask_get_addr_8_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_8_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_get_addr_8_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_mask_get_addr_8(cmask, x, y); + var retStruct = new SkiaSharp.sk_mask_get_addr_8_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_8_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_get_addr_8_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_get_addr_lcd_16_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_get_addr_lcd_16_0_Return(); + var parms = SkiaSharp.sk_mask_get_addr_lcd_16_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_lcd_16_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_get_addr_lcd_16_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_mask_get_addr_lcd_16(cmask, x, y); + var retStruct = new SkiaSharp.sk_mask_get_addr_lcd_16_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_lcd_16_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_get_addr_lcd_16_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_get_addr_32_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_get_addr_32_0_Return(); + var parms = SkiaSharp.sk_mask_get_addr_32_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_32_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_get_addr_32_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_mask_get_addr_32(cmask, x, y); + var retStruct = new SkiaSharp.sk_mask_get_addr_32_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_32_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_get_addr_32_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_mask_get_addr_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_mask_get_addr_0_Return(); + var parms = SkiaSharp.sk_mask_get_addr_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_0_Pre) { + SkiaSharp.ApiOverride.sk_mask_get_addr_0_Pre(parms); + } + var cmask = parms.cmask.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_mask_get_addr(cmask, x, y); + var retStruct = new SkiaSharp.sk_mask_get_addr_0_Return(); + retStruct.cmask = SkiaSharp.SKMask.unmarshal(cmask, CanvasKit); + if (SkiaSharp.ApiOverride.sk_mask_get_addr_0_Post) { + ret = SkiaSharp.ApiOverride.sk_mask_get_addr_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_try_invert_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_try_invert_0_Return(); + var parms = SkiaSharp.sk_matrix_try_invert_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_try_invert_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_try_invert_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var result = retStruct.result.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_try_invert(matrix, result); + var retStruct = new SkiaSharp.sk_matrix_try_invert_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + retStruct.result = SkiaSharp.SKMatrix.unmarshal(result, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_try_invert_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_try_invert_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_concat_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_concat_0_Return(); + var parms = SkiaSharp.sk_matrix_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_concat_0_Pre(parms); + } + var target = parms.target.marshalNew(CanvasKit); + var first = parms.first.marshalNew(CanvasKit); + var second = parms.second.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_concat(target, first, second); + var retStruct = new SkiaSharp.sk_matrix_concat_0_Return(); + retStruct.target = SkiaSharp.SKMatrix.unmarshal(target, CanvasKit); + retStruct.first = SkiaSharp.SKMatrix.unmarshal(first, CanvasKit); + retStruct.second = SkiaSharp.SKMatrix.unmarshal(second, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_concat_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_pre_concat_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_pre_concat_0_Return(); + var parms = SkiaSharp.sk_matrix_pre_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_pre_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_pre_concat_0_Pre(parms); + } + var target = parms.target.marshalNew(CanvasKit); + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_pre_concat(target, matrix); + var retStruct = new SkiaSharp.sk_matrix_pre_concat_0_Return(); + retStruct.target = SkiaSharp.SKMatrix.unmarshal(target, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_pre_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_pre_concat_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_post_concat_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_post_concat_0_Return(); + var parms = SkiaSharp.sk_matrix_post_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_post_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_post_concat_0_Pre(parms); + } + var target = parms.target.marshalNew(CanvasKit); + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_post_concat(target, matrix); + var retStruct = new SkiaSharp.sk_matrix_post_concat_0_Return(); + retStruct.target = SkiaSharp.SKMatrix.unmarshal(target, CanvasKit); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_post_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_post_concat_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_rect_0_Return(); + var parms = SkiaSharp.sk_matrix_map_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_rect_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var dest = retStruct.dest.marshalNew(CanvasKit); + var source = parms.source.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_map_rect(matrix, dest, source); + var retStruct = new SkiaSharp.sk_matrix_map_rect_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + retStruct.dest = SkiaSharp.SKRect.unmarshal(dest, CanvasKit); + retStruct.source = SkiaSharp.SKRect.unmarshal(source, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_points_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_points_0_Return(); + var parms = SkiaSharp.sk_matrix_map_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_points_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_points_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var dst = parms.dst; + var src = parms.src; + var count = parms.count; + var ret = CanvasKit._sk_matrix_map_points(matrix, dst, src, count); + var retStruct = new SkiaSharp.sk_matrix_map_points_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_points_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_vectors_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_vectors_0_Return(); + var parms = SkiaSharp.sk_matrix_map_vectors_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_vectors_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_vectors_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var dst = parms.dst; + var src = parms.src; + var count = parms.count; + var ret = CanvasKit._sk_matrix_map_vectors(matrix, dst, src, count); + var retStruct = new SkiaSharp.sk_matrix_map_vectors_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_vectors_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_vectors_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_xy_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_xy_0_Return(); + var parms = SkiaSharp.sk_matrix_map_xy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_xy_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_xy_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var result = retStruct.result.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_map_xy(matrix, x, y, result); + var retStruct = new SkiaSharp.sk_matrix_map_xy_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + retStruct.result = SkiaSharp.SKPoint.unmarshal(result, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_xy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_xy_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_vector_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_vector_0_Return(); + var parms = SkiaSharp.sk_matrix_map_vector_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_vector_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_vector_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var x = parms.x; + var y = parms.y; + var result = retStruct.result.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix_map_vector(matrix, x, y, result); + var retStruct = new SkiaSharp.sk_matrix_map_vector_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + retStruct.result = SkiaSharp.SKPoint.unmarshal(result, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_vector_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_vector_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix_map_radius_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix_map_radius_0_Return(); + var parms = SkiaSharp.sk_matrix_map_radius_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix_map_radius_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix_map_radius_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var radius = parms.radius; + var ret = CanvasKit._sk_matrix_map_radius(matrix, radius); + var retStruct = new SkiaSharp.sk_matrix_map_radius_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix_map_radius_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix_map_radius_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_3dview_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_3dview_new(); + if (SkiaSharp.ApiOverride.sk_3dview_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_new_0_Post(ret); + } + return ret; + } + static sk_3dview_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_destroy_0_Pre(parms); + } + var cview = parms.cview; + var ret = CanvasKit._sk_3dview_destroy(cview); + if (SkiaSharp.ApiOverride.sk_3dview_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_save_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_save_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_save_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_save_0_Pre(parms); + } + var cview = parms.cview; + var ret = CanvasKit._sk_3dview_save(cview); + if (SkiaSharp.ApiOverride.sk_3dview_save_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_save_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_restore_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_restore_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_restore_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_restore_0_Pre(parms); + } + var cview = parms.cview; + var ret = CanvasKit._sk_3dview_restore(cview); + if (SkiaSharp.ApiOverride.sk_3dview_restore_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_restore_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_translate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_translate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_translate_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_translate_0_Pre(parms); + } + var cview = parms.cview; + var x = parms.x; + var y = parms.y; + var z = parms.z; + var ret = CanvasKit._sk_3dview_translate(cview, x, y, z); + if (SkiaSharp.ApiOverride.sk_3dview_translate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_translate_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_x_degrees_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_x_degrees_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_x_degrees_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_x_degrees_0_Pre(parms); + } + var cview = parms.cview; + var degrees = parms.degrees; + var ret = CanvasKit._sk_3dview_rotate_x_degrees(cview, degrees); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_x_degrees_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_x_degrees_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_y_degrees_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_y_degrees_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_y_degrees_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_y_degrees_0_Pre(parms); + } + var cview = parms.cview; + var degrees = parms.degrees; + var ret = CanvasKit._sk_3dview_rotate_y_degrees(cview, degrees); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_y_degrees_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_y_degrees_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_z_degrees_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_z_degrees_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_z_degrees_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_z_degrees_0_Pre(parms); + } + var cview = parms.cview; + var degrees = parms.degrees; + var ret = CanvasKit._sk_3dview_rotate_z_degrees(cview, degrees); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_z_degrees_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_z_degrees_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_x_radians_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_x_radians_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_x_radians_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_x_radians_0_Pre(parms); + } + var cview = parms.cview; + var radians = parms.radians; + var ret = CanvasKit._sk_3dview_rotate_x_radians(cview, radians); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_x_radians_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_x_radians_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_y_radians_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_y_radians_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_y_radians_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_y_radians_0_Pre(parms); + } + var cview = parms.cview; + var radians = parms.radians; + var ret = CanvasKit._sk_3dview_rotate_y_radians(cview, radians); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_y_radians_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_y_radians_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_rotate_z_radians_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_rotate_z_radians_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_z_radians_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_rotate_z_radians_0_Pre(parms); + } + var cview = parms.cview; + var radians = parms.radians; + var ret = CanvasKit._sk_3dview_rotate_z_radians(cview, radians); + if (SkiaSharp.ApiOverride.sk_3dview_rotate_z_radians_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_rotate_z_radians_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_get_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_3dview_get_matrix_0_Return(); + var parms = SkiaSharp.sk_3dview_get_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_get_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_get_matrix_0_Pre(parms); + } + var cview = parms.cview; + var cmatrix = parms.cmatrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_3dview_get_matrix(cview, cmatrix); + var retStruct = new SkiaSharp.sk_3dview_get_matrix_0_Return(); + retStruct.cmatrix = SkiaSharp.SKMatrix.unmarshal(cmatrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_3dview_get_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_get_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_3dview_apply_to_canvas_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_apply_to_canvas_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_apply_to_canvas_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_apply_to_canvas_0_Pre(parms); + } + var cview = parms.cview; + var ccanvas = parms.ccanvas; + var ret = CanvasKit._sk_3dview_apply_to_canvas(cview, ccanvas); + if (SkiaSharp.ApiOverride.sk_3dview_apply_to_canvas_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_apply_to_canvas_0_Post(ret, parms); + } + return ret; + } + static sk_3dview_dot_with_normal_0(pParams, pReturn) { + var parms = SkiaSharp.sk_3dview_dot_with_normal_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_3dview_dot_with_normal_0_Pre) { + SkiaSharp.ApiOverride.sk_3dview_dot_with_normal_0_Pre(parms); + } + var cview = parms.cview; + var dx = parms.dx; + var dy = parms.dy; + var dz = parms.dz; + var ret = CanvasKit._sk_3dview_dot_with_normal(cview, dx, dy, dz); + if (SkiaSharp.ApiOverride.sk_3dview_dot_with_normal_0_Post) { + ret = SkiaSharp.ApiOverride.sk_3dview_dot_with_normal_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_destroy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_destroy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_destroy_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_destroy_0_Pre(parms); + } + var matrix = parms.matrix; + var ret = CanvasKit._sk_matrix44_destroy(matrix); + if (SkiaSharp.ApiOverride.sk_matrix44_destroy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_destroy_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_matrix44_new(); + if (SkiaSharp.ApiOverride.sk_matrix44_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_new_0_Post(ret); + } + return ret; + } + static sk_matrix44_new_identity_0(pParams, pReturn) { + var ret = CanvasKit._sk_matrix44_new_identity(); + if (SkiaSharp.ApiOverride.sk_matrix44_new_identity_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_new_identity_0_Post(ret); + } + return ret; + } + static sk_matrix44_new_copy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_new_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_new_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_new_copy_0_Pre(parms); + } + var src = parms.src; + var ret = CanvasKit._sk_matrix44_new_copy(src); + if (SkiaSharp.ApiOverride.sk_matrix44_new_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_new_copy_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_new_concat_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_new_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_new_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_new_concat_0_Pre(parms); + } + var a = parms.a; + var b = parms.b; + var ret = CanvasKit._sk_matrix44_new_concat(a, b); + if (SkiaSharp.ApiOverride.sk_matrix44_new_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_new_concat_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_new_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix44_new_matrix_0_Return(); + var parms = SkiaSharp.sk_matrix44_new_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_new_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_new_matrix_0_Pre(parms); + } + var src = parms.src.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix44_new_matrix(src); + var retStruct = new SkiaSharp.sk_matrix44_new_matrix_0_Return(); + retStruct.src = SkiaSharp.SKMatrix.unmarshal(src, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix44_new_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_new_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix44_equals_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_equals_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_equals_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_equals_0_Pre(parms); + } + var matrix = parms.matrix; + var other = parms.other; + var ret = CanvasKit._sk_matrix44_equals(matrix, other); + if (SkiaSharp.ApiOverride.sk_matrix44_equals_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_equals_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_to_matrix_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_matrix44_to_matrix_0_Return(); + var parms = SkiaSharp.sk_matrix44_to_matrix_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_to_matrix_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_to_matrix_0_Pre(parms); + } + var matrix = parms.matrix; + var dst = retStruct.dst.marshalNew(CanvasKit); + var ret = CanvasKit._sk_matrix44_to_matrix(matrix, dst); + var retStruct = new SkiaSharp.sk_matrix44_to_matrix_0_Return(); + retStruct.dst = SkiaSharp.SKMatrix.unmarshal(dst, CanvasKit); + if (SkiaSharp.ApiOverride.sk_matrix44_to_matrix_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_to_matrix_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_matrix44_get_type_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_get_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_get_type_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_get_type_0_Pre(parms); + } + var matrix = parms.matrix; + var ret = CanvasKit._sk_matrix44_get_type(matrix); + if (SkiaSharp.ApiOverride.sk_matrix44_get_type_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_get_type_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_identity_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_identity_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_identity_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_identity_0_Pre(parms); + } + var matrix = parms.matrix; + var ret = CanvasKit._sk_matrix44_set_identity(matrix); + if (SkiaSharp.ApiOverride.sk_matrix44_set_identity_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_identity_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_get_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_get_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_get_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_get_0_Pre(parms); + } + var matrix = parms.matrix; + var row = parms.row; + var col = parms.col; + var ret = CanvasKit._sk_matrix44_get(matrix, row, col); + if (SkiaSharp.ApiOverride.sk_matrix44_get_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_get_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_0_Pre(parms); + } + var matrix = parms.matrix; + var row = parms.row; + var col = parms.col; + var value = parms.value; + var ret = CanvasKit._sk_matrix44_set(matrix, row, col, value); + if (SkiaSharp.ApiOverride.sk_matrix44_set_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_as_col_major_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_as_col_major_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_as_col_major_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_as_col_major_0_Pre(parms); + } + var matrix = parms.matrix; + var dst = CanvasKit._malloc(parms.dst_Length * 4); /*float*/ + var dst_f32 = dst / 4; + { + for (var i = 0; i < parms.dst_Length; i++) { + CanvasKit.HEAPF32[dst_f32 + i] = parms.dst[i]; + } + } + var ret = CanvasKit._sk_matrix44_as_col_major(matrix, dst); + if (SkiaSharp.ApiOverride.sk_matrix44_as_col_major_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_as_col_major_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_as_row_major_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_as_row_major_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_as_row_major_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_as_row_major_0_Pre(parms); + } + var matrix = parms.matrix; + var dst = CanvasKit._malloc(parms.dst_Length * 4); /*float*/ + var dst_f32 = dst / 4; + { + for (var i = 0; i < parms.dst_Length; i++) { + CanvasKit.HEAPF32[dst_f32 + i] = parms.dst[i]; + } + } + var ret = CanvasKit._sk_matrix44_as_row_major(matrix, dst); + if (SkiaSharp.ApiOverride.sk_matrix44_as_row_major_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_as_row_major_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_col_major_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_col_major_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_col_major_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_col_major_0_Pre(parms); + } + var matrix = parms.matrix; + var src = CanvasKit._malloc(parms.src_Length * 4); /*float*/ + var src_f32 = src / 4; + { + for (var i = 0; i < parms.src_Length; i++) { + CanvasKit.HEAPF32[src_f32 + i] = parms.src[i]; + } + } + var ret = CanvasKit._sk_matrix44_set_col_major(matrix, src); + if (SkiaSharp.ApiOverride.sk_matrix44_set_col_major_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_col_major_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_row_major_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_row_major_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_row_major_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_row_major_0_Pre(parms); + } + var matrix = parms.matrix; + var src = CanvasKit._malloc(parms.src_Length * 4); /*float*/ + var src_f32 = src / 4; + { + for (var i = 0; i < parms.src_Length; i++) { + CanvasKit.HEAPF32[src_f32 + i] = parms.src[i]; + } + } + var ret = CanvasKit._sk_matrix44_set_row_major(matrix, src); + if (SkiaSharp.ApiOverride.sk_matrix44_set_row_major_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_row_major_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_translate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_translate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_translate_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_translate_0_Pre(parms); + } + var matrix = parms.matrix; + var dx = parms.dx; + var dy = parms.dy; + var dz = parms.dz; + var ret = CanvasKit._sk_matrix44_set_translate(matrix, dx, dy, dz); + if (SkiaSharp.ApiOverride.sk_matrix44_set_translate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_translate_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_pre_translate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_pre_translate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_translate_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_pre_translate_0_Pre(parms); + } + var matrix = parms.matrix; + var dx = parms.dx; + var dy = parms.dy; + var dz = parms.dz; + var ret = CanvasKit._sk_matrix44_pre_translate(matrix, dx, dy, dz); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_translate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_pre_translate_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_post_translate_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_post_translate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_post_translate_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_post_translate_0_Pre(parms); + } + var matrix = parms.matrix; + var dx = parms.dx; + var dy = parms.dy; + var dz = parms.dz; + var ret = CanvasKit._sk_matrix44_post_translate(matrix, dx, dy, dz); + if (SkiaSharp.ApiOverride.sk_matrix44_post_translate_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_post_translate_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_scale_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_scale_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_scale_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_scale_0_Pre(parms); + } + var matrix = parms.matrix; + var sx = parms.sx; + var sy = parms.sy; + var sz = parms.sz; + var ret = CanvasKit._sk_matrix44_set_scale(matrix, sx, sy, sz); + if (SkiaSharp.ApiOverride.sk_matrix44_set_scale_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_scale_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_pre_scale_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_pre_scale_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_scale_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_pre_scale_0_Pre(parms); + } + var matrix = parms.matrix; + var sx = parms.sx; + var sy = parms.sy; + var sz = parms.sz; + var ret = CanvasKit._sk_matrix44_pre_scale(matrix, sx, sy, sz); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_scale_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_pre_scale_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_post_scale_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_post_scale_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_post_scale_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_post_scale_0_Pre(parms); + } + var matrix = parms.matrix; + var sx = parms.sx; + var sy = parms.sy; + var sz = parms.sz; + var ret = CanvasKit._sk_matrix44_post_scale(matrix, sx, sy, sz); + if (SkiaSharp.ApiOverride.sk_matrix44_post_scale_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_post_scale_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_rotate_about_degrees_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_rotate_about_degrees_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_degrees_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_degrees_0_Pre(parms); + } + var matrix = parms.matrix; + var x = parms.x; + var y = parms.y; + var z = parms.z; + var degrees = parms.degrees; + var ret = CanvasKit._sk_matrix44_set_rotate_about_degrees(matrix, x, y, z, degrees); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_degrees_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_degrees_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_rotate_about_radians_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_rotate_about_radians_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_0_Pre(parms); + } + var matrix = parms.matrix; + var x = parms.x; + var y = parms.y; + var z = parms.z; + var radians = parms.radians; + var ret = CanvasKit._sk_matrix44_set_rotate_about_radians(matrix, x, y, z, radians); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_rotate_about_radians_unit_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_rotate_about_radians_unit_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_unit_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_unit_0_Pre(parms); + } + var matrix = parms.matrix; + var x = parms.x; + var y = parms.y; + var z = parms.z; + var radians = parms.radians; + var ret = CanvasKit._sk_matrix44_set_rotate_about_radians_unit(matrix, x, y, z, radians); + if (SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_unit_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_rotate_about_radians_unit_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_set_concat_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_set_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_set_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_set_concat_0_Pre(parms); + } + var matrix = parms.matrix; + var a = parms.a; + var b = parms.b; + var ret = CanvasKit._sk_matrix44_set_concat(matrix, a, b); + if (SkiaSharp.ApiOverride.sk_matrix44_set_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_set_concat_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_pre_concat_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_pre_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_pre_concat_0_Pre(parms); + } + var matrix = parms.matrix; + var m = parms.m; + var ret = CanvasKit._sk_matrix44_pre_concat(matrix, m); + if (SkiaSharp.ApiOverride.sk_matrix44_pre_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_pre_concat_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_post_concat_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_post_concat_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_post_concat_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_post_concat_0_Pre(parms); + } + var matrix = parms.matrix; + var m = parms.m; + var ret = CanvasKit._sk_matrix44_post_concat(matrix, m); + if (SkiaSharp.ApiOverride.sk_matrix44_post_concat_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_post_concat_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_invert_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_invert_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_invert_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_invert_0_Pre(parms); + } + var matrix = parms.matrix; + var inverse = parms.inverse; + var ret = CanvasKit._sk_matrix44_invert(matrix, inverse); + if (SkiaSharp.ApiOverride.sk_matrix44_invert_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_invert_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_transpose_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_transpose_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_transpose_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_transpose_0_Pre(parms); + } + var matrix = parms.matrix; + var ret = CanvasKit._sk_matrix44_transpose(matrix); + if (SkiaSharp.ApiOverride.sk_matrix44_transpose_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_transpose_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_map_scalars_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_map_scalars_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_map_scalars_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_map_scalars_0_Pre(parms); + } + var matrix = parms.matrix; + var src = CanvasKit._malloc(parms.src_Length * 4); /*float*/ + var src_f32 = src / 4; + { + for (var i = 0; i < parms.src_Length; i++) { + CanvasKit.HEAPF32[src_f32 + i] = parms.src[i]; + } + } + var dst = CanvasKit._malloc(parms.dst_Length * 4); /*float*/ + var dst_f32 = dst / 4; + { + for (var i = 0; i < parms.dst_Length; i++) { + CanvasKit.HEAPF32[dst_f32 + i] = parms.dst[i]; + } + } + var ret = CanvasKit._sk_matrix44_map_scalars(matrix, src, dst); + if (SkiaSharp.ApiOverride.sk_matrix44_map_scalars_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_map_scalars_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_map2_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_map2_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_map2_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_map2_0_Pre(parms); + } + var matrix = parms.matrix; + var src2 = CanvasKit._malloc(parms.src2_Length * 4); /*float*/ + var src2_f32 = src2 / 4; + { + for (var i = 0; i < parms.src2_Length; i++) { + CanvasKit.HEAPF32[src2_f32 + i] = parms.src2[i]; + } + } + var count = parms.count; + var dst = CanvasKit._malloc(parms.dst_Length * 4); /*float*/ + var dst_f32 = dst / 4; + { + for (var i = 0; i < parms.dst_Length; i++) { + CanvasKit.HEAPF32[dst_f32 + i] = parms.dst[i]; + } + } + var ret = CanvasKit._sk_matrix44_map2(matrix, src2, count, dst); + if (SkiaSharp.ApiOverride.sk_matrix44_map2_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_map2_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_preserves_2d_axis_alignment_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_preserves_2d_axis_alignment_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_preserves_2d_axis_alignment_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_preserves_2d_axis_alignment_0_Pre(parms); + } + var matrix = parms.matrix; + var epsilon = parms.epsilon; + var ret = CanvasKit._sk_matrix44_preserves_2d_axis_alignment(matrix, epsilon); + if (SkiaSharp.ApiOverride.sk_matrix44_preserves_2d_axis_alignment_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_preserves_2d_axis_alignment_0_Post(ret, parms); + } + return ret; + } + static sk_matrix44_determinant_0(pParams, pReturn) { + var parms = SkiaSharp.sk_matrix44_determinant_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_matrix44_determinant_0_Pre) { + SkiaSharp.ApiOverride.sk_matrix44_determinant_0_Pre(parms); + } + var matrix = parms.matrix; + var ret = CanvasKit._sk_matrix44_determinant(matrix); + if (SkiaSharp.ApiOverride.sk_matrix44_determinant_0_Post) { + ret = SkiaSharp.ApiOverride.sk_matrix44_determinant_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_unref_0_Pre(parms); + } + var effect = parms.effect; + var ret = CanvasKit._sk_path_effect_unref(effect); + if (SkiaSharp.ApiOverride.sk_path_effect_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_unref_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_compose_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_compose_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_compose_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_compose_0_Pre(parms); + } + var outer = parms.outer; + var inner = parms.inner; + var ret = CanvasKit._sk_path_effect_create_compose(outer, inner); + if (SkiaSharp.ApiOverride.sk_path_effect_create_compose_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_compose_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_sum_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_sum_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_sum_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_sum_0_Pre(parms); + } + var first = parms.first; + var second = parms.second; + var ret = CanvasKit._sk_path_effect_create_sum(first, second); + if (SkiaSharp.ApiOverride.sk_path_effect_create_sum_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_sum_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_discrete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_discrete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_discrete_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_discrete_0_Pre(parms); + } + var segLength = parms.segLength; + var deviation = parms.deviation; + var seedAssist = parms.seedAssist; + var ret = CanvasKit._sk_path_effect_create_discrete(segLength, deviation, seedAssist); + if (SkiaSharp.ApiOverride.sk_path_effect_create_discrete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_discrete_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_corner_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_corner_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_corner_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_corner_0_Pre(parms); + } + var radius = parms.radius; + var ret = CanvasKit._sk_path_effect_create_corner(radius); + if (SkiaSharp.ApiOverride.sk_path_effect_create_corner_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_corner_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_1d_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_1d_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_1d_path_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_1d_path_0_Pre(parms); + } + var path = parms.path; + var advance = parms.advance; + var phase = parms.phase; + var style = parms.style; + var ret = CanvasKit._sk_path_effect_create_1d_path(path, advance, phase, style); + if (SkiaSharp.ApiOverride.sk_path_effect_create_1d_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_1d_path_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_2d_line_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_effect_create_2d_line_0_Return(); + var parms = SkiaSharp.sk_path_effect_create_2d_line_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_2d_line_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_2d_line_0_Pre(parms); + } + var width = parms.width; + var matrix = parms.matrix.marshalNew(CanvasKit); + var ret = CanvasKit._sk_path_effect_create_2d_line(width, matrix); + var retStruct = new SkiaSharp.sk_path_effect_create_2d_line_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_effect_create_2d_line_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_2d_line_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_effect_create_2d_path_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_path_effect_create_2d_path_0_Return(); + var parms = SkiaSharp.sk_path_effect_create_2d_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_2d_path_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_2d_path_0_Pre(parms); + } + var matrix = parms.matrix.marshalNew(CanvasKit); + var path = parms.path; + var ret = CanvasKit._sk_path_effect_create_2d_path(matrix, path); + var retStruct = new SkiaSharp.sk_path_effect_create_2d_path_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_path_effect_create_2d_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_2d_path_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_path_effect_create_dash_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_dash_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_dash_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_dash_0_Pre(parms); + } + var intervals = CanvasKit._malloc(parms.intervals_Length * 4); /*float*/ + var intervals_f32 = intervals / 4; + { + for (var i = 0; i < parms.intervals_Length; i++) { + CanvasKit.HEAPF32[intervals_f32 + i] = parms.intervals[i]; + } + } + var count = parms.count; + var phase = parms.phase; + var ret = CanvasKit._sk_path_effect_create_dash(intervals, count, phase); + if (SkiaSharp.ApiOverride.sk_path_effect_create_dash_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_dash_0_Post(ret, parms); + } + return ret; + } + static sk_path_effect_create_trim_0(pParams, pReturn) { + var parms = SkiaSharp.sk_path_effect_create_trim_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_path_effect_create_trim_0_Pre) { + SkiaSharp.ApiOverride.sk_path_effect_create_trim_0_Pre(parms); + } + var start = parms.start; + var stop = parms.stop; + var mode = parms.mode; + var ret = CanvasKit._sk_path_effect_create_trim(start, stop, mode); + if (SkiaSharp.ApiOverride.sk_path_effect_create_trim_0_Post) { + ret = SkiaSharp.ApiOverride.sk_path_effect_create_trim_0_Post(ret, parms); + } + return ret; + } + static sk_colortable_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colortable_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colortable_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_colortable_unref_0_Pre(parms); + } + var ctable = parms.ctable; + var ret = CanvasKit._sk_colortable_unref(ctable); + if (SkiaSharp.ApiOverride.sk_colortable_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colortable_unref_0_Post(ret, parms); + } + return ret; + } + static sk_colortable_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colortable_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colortable_new_0_Pre) { + SkiaSharp.ApiOverride.sk_colortable_new_0_Pre(parms); + } + var colors = parms.colors; + var count = parms.count; + var ret = CanvasKit._sk_colortable_new(colors, count); + if (SkiaSharp.ApiOverride.sk_colortable_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colortable_new_0_Post(ret, parms); + } + return ret; + } + static sk_colortable_count_0(pParams, pReturn) { + var parms = SkiaSharp.sk_colortable_count_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colortable_count_0_Pre) { + SkiaSharp.ApiOverride.sk_colortable_count_0_Pre(parms); + } + var ctable = parms.ctable; + var ret = CanvasKit._sk_colortable_count(ctable); + if (SkiaSharp.ApiOverride.sk_colortable_count_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colortable_count_0_Post(ret, parms); + } + return ret; + } + static sk_colortable_read_colors_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_colortable_read_colors_0_Return(); + var parms = SkiaSharp.sk_colortable_read_colors_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_colortable_read_colors_0_Pre) { + SkiaSharp.ApiOverride.sk_colortable_read_colors_0_Pre(parms); + } + var ctable = parms.ctable; + var colors = CanvasKit._malloc(4); + var ret = CanvasKit._sk_colortable_read_colors(ctable, colors); + var retStruct = new SkiaSharp.sk_colortable_read_colors_0_Return(); + retStruct.colors = CanvasKit.getValue(colors, "i32"); + if (SkiaSharp.ApiOverride.sk_colortable_read_colors_0_Post) { + ret = SkiaSharp.ApiOverride.sk_colortable_read_colors_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_context_make_gl_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_make_gl_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_make_gl_0_Pre) { + SkiaSharp.ApiOverride.gr_context_make_gl_0_Pre(parms); + } + var glInterface = parms.glInterface; + var ret = CanvasKit._gr_context_make_gl(glInterface); + if (SkiaSharp.ApiOverride.gr_context_make_gl_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_make_gl_0_Post(ret, parms); + } + return ret; + } + static gr_context_unref_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_unref_0_Pre) { + SkiaSharp.ApiOverride.gr_context_unref_0_Pre(parms); + } + var context = parms.context; + var ret = CanvasKit._gr_context_unref(context); + if (SkiaSharp.ApiOverride.gr_context_unref_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_unref_0_Post(ret, parms); + } + return ret; + } + static gr_context_abandon_context_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_abandon_context_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_abandon_context_0_Pre) { + SkiaSharp.ApiOverride.gr_context_abandon_context_0_Pre(parms); + } + var context = parms.context; + var ret = CanvasKit._gr_context_abandon_context(context); + if (SkiaSharp.ApiOverride.gr_context_abandon_context_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_abandon_context_0_Post(ret, parms); + } + return ret; + } + static gr_context_release_resources_and_abandon_context_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_release_resources_and_abandon_context_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_release_resources_and_abandon_context_0_Pre) { + SkiaSharp.ApiOverride.gr_context_release_resources_and_abandon_context_0_Pre(parms); + } + var context = parms.context; + var ret = CanvasKit._gr_context_release_resources_and_abandon_context(context); + if (SkiaSharp.ApiOverride.gr_context_release_resources_and_abandon_context_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_release_resources_and_abandon_context_0_Post(ret, parms); + } + return ret; + } + static gr_context_get_resource_cache_limits_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_context_get_resource_cache_limits_0_Return(); + var parms = SkiaSharp.gr_context_get_resource_cache_limits_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_get_resource_cache_limits_0_Pre) { + SkiaSharp.ApiOverride.gr_context_get_resource_cache_limits_0_Pre(parms); + } + var context = parms.context; + var maxResources = CanvasKit._malloc(4); + var maxResourceBytes = CanvasKit._malloc(4); + var ret = CanvasKit._gr_context_get_resource_cache_limits(context, maxResources, maxResourceBytes); + var retStruct = new SkiaSharp.gr_context_get_resource_cache_limits_0_Return(); + retStruct.maxResources = CanvasKit.getValue(maxResources, "i32"); + retStruct.maxResourceBytes = CanvasKit.getValue(maxResourceBytes, "i32"); + if (SkiaSharp.ApiOverride.gr_context_get_resource_cache_limits_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_get_resource_cache_limits_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_context_set_resource_cache_limits_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_set_resource_cache_limits_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_set_resource_cache_limits_0_Pre) { + SkiaSharp.ApiOverride.gr_context_set_resource_cache_limits_0_Pre(parms); + } + var context = parms.context; + var maxResources = parms.maxResources; + var maxResourceBytes = parms.maxResourceBytes; + var ret = CanvasKit._gr_context_set_resource_cache_limits(context, maxResources, maxResourceBytes); + if (SkiaSharp.ApiOverride.gr_context_set_resource_cache_limits_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_set_resource_cache_limits_0_Post(ret, parms); + } + return ret; + } + static gr_context_get_resource_cache_usage_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_context_get_resource_cache_usage_0_Return(); + var parms = SkiaSharp.gr_context_get_resource_cache_usage_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_get_resource_cache_usage_0_Pre) { + SkiaSharp.ApiOverride.gr_context_get_resource_cache_usage_0_Pre(parms); + } + var context = parms.context; + var maxResources = CanvasKit._malloc(4); + var maxResourceBytes = CanvasKit._malloc(4); + var ret = CanvasKit._gr_context_get_resource_cache_usage(context, maxResources, maxResourceBytes); + var retStruct = new SkiaSharp.gr_context_get_resource_cache_usage_0_Return(); + retStruct.maxResources = CanvasKit.getValue(maxResources, "i32"); + retStruct.maxResourceBytes = CanvasKit.getValue(maxResourceBytes, "i32"); + if (SkiaSharp.ApiOverride.gr_context_get_resource_cache_usage_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_get_resource_cache_usage_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_context_get_max_surface_sample_count_for_color_type_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_get_max_surface_sample_count_for_color_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_get_max_surface_sample_count_for_color_type_0_Pre) { + SkiaSharp.ApiOverride.gr_context_get_max_surface_sample_count_for_color_type_0_Pre(parms); + } + var context = parms.context; + var colorType = parms.colorType; + var ret = CanvasKit._gr_context_get_max_surface_sample_count_for_color_type(context, colorType); + if (SkiaSharp.ApiOverride.gr_context_get_max_surface_sample_count_for_color_type_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_get_max_surface_sample_count_for_color_type_0_Post(ret, parms); + } + return ret; + } + static gr_context_flush_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_flush_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_flush_0_Pre) { + SkiaSharp.ApiOverride.gr_context_flush_0_Pre(parms); + } + var context = parms.context; + var ret = CanvasKit._gr_context_flush(context); + if (SkiaSharp.ApiOverride.gr_context_flush_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_flush_0_Post(ret, parms); + } + return ret; + } + static gr_context_reset_context_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_reset_context_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_reset_context_0_Pre) { + SkiaSharp.ApiOverride.gr_context_reset_context_0_Pre(parms); + } + var context = parms.context; + var state = parms.state; + var ret = CanvasKit._gr_context_reset_context(context, state); + if (SkiaSharp.ApiOverride.gr_context_reset_context_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_reset_context_0_Post(ret, parms); + } + return ret; + } + static gr_context_get_backend_0(pParams, pReturn) { + var parms = SkiaSharp.gr_context_get_backend_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_context_get_backend_0_Pre) { + SkiaSharp.ApiOverride.gr_context_get_backend_0_Pre(parms); + } + var context = parms.context; + var ret = CanvasKit._gr_context_get_backend(context); + if (SkiaSharp.ApiOverride.gr_context_get_backend_0_Post) { + ret = SkiaSharp.ApiOverride.gr_context_get_backend_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_assemble_interface_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_assemble_interface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_interface_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_assemble_interface_0_Pre(parms); + } + var ctx = parms.ctx; + var get = parms.get; + var ret = CanvasKit._gr_glinterface_assemble_interface(ctx, get); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_interface_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_assemble_interface_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_assemble_gl_interface_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_assemble_gl_interface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_gl_interface_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_assemble_gl_interface_0_Pre(parms); + } + var ctx = parms.ctx; + var get = parms.get; + var ret = CanvasKit._gr_glinterface_assemble_gl_interface(ctx, get); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_gl_interface_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_assemble_gl_interface_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_assemble_gles_interface_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_assemble_gles_interface_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_gles_interface_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_assemble_gles_interface_0_Pre(parms); + } + var ctx = parms.ctx; + var get = parms.get; + var ret = CanvasKit._gr_glinterface_assemble_gles_interface(ctx, get); + if (SkiaSharp.ApiOverride.gr_glinterface_assemble_gles_interface_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_assemble_gles_interface_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_create_native_interface_0(pParams, pReturn) { + var ret = CanvasKit._gr_glinterface_create_native_interface(); + if (SkiaSharp.ApiOverride.gr_glinterface_create_native_interface_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_create_native_interface_0_Post(ret); + } + return ret; + } + static gr_glinterface_unref_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_unref_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_unref_0_Pre(parms); + } + var glInterface = parms.glInterface; + var ret = CanvasKit._gr_glinterface_unref(glInterface); + if (SkiaSharp.ApiOverride.gr_glinterface_unref_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_unref_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_validate_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_validate_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_validate_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_validate_0_Pre(parms); + } + var glInterface = parms.glInterface; + var ret = CanvasKit._gr_glinterface_validate(glInterface); + if (SkiaSharp.ApiOverride.gr_glinterface_validate_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_validate_0_Post(ret, parms); + } + return ret; + } + static gr_glinterface_has_extension_0(pParams, pReturn) { + var parms = SkiaSharp.gr_glinterface_has_extension_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_glinterface_has_extension_0_Pre) { + SkiaSharp.ApiOverride.gr_glinterface_has_extension_0_Pre(parms); + } + var glInterface = parms.glInterface; + var extension_Length = parms.extension.length * 4 + 1; + var extension = CanvasKit._malloc(extension_Length); + CanvasKit.stringToUTF8(parms.extension, extension, extension_Length); + var ret = CanvasKit._gr_glinterface_has_extension(glInterface, extension); + if (SkiaSharp.ApiOverride.gr_glinterface_has_extension_0_Post) { + ret = SkiaSharp.ApiOverride.gr_glinterface_has_extension_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_new_gl_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_backendtexture_new_gl_0_Return(); + var parms = SkiaSharp.gr_backendtexture_new_gl_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_new_gl_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_new_gl_0_Pre(parms); + } + var width = parms.width; + var height = parms.height; + var mipmapped = parms.mipmapped; + var glInfo = parms.glInfo.marshalNew(CanvasKit); + var ret = CanvasKit._gr_backendtexture_new_gl(width, height, mipmapped, glInfo); + var retStruct = new SkiaSharp.gr_backendtexture_new_gl_0_Return(); + retStruct.glInfo = SkiaSharp.GRGlTextureInfo.unmarshal(glInfo, CanvasKit); + if (SkiaSharp.ApiOverride.gr_backendtexture_new_gl_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_new_gl_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_backendtexture_delete_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_delete_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_delete_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_delete(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_delete_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_delete_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_is_valid_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_is_valid_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_is_valid_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_is_valid_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_is_valid(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_is_valid_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_is_valid_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_get_width_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_get_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_width_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_get_width_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_get_width(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_width_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_get_width_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_get_height_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_get_height_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_height_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_get_height_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_get_height(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_height_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_get_height_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_has_mipmaps_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_has_mipmaps_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_has_mipmaps_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_has_mipmaps_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_has_mipmaps(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_has_mipmaps_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_has_mipmaps_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_get_backend_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendtexture_get_backend_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_backend_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_get_backend_0_Pre(parms); + } + var texture = parms.texture; + var ret = CanvasKit._gr_backendtexture_get_backend(texture); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_backend_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_get_backend_0_Post(ret, parms); + } + return ret; + } + static gr_backendtexture_get_gl_textureinfo_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_backendtexture_get_gl_textureinfo_0_Return(); + var parms = SkiaSharp.gr_backendtexture_get_gl_textureinfo_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_gl_textureinfo_0_Pre) { + SkiaSharp.ApiOverride.gr_backendtexture_get_gl_textureinfo_0_Pre(parms); + } + var texture = parms.texture; + var glInfo = retStruct.glInfo.marshalNew(CanvasKit); + var ret = CanvasKit._gr_backendtexture_get_gl_textureinfo(texture, glInfo); + var retStruct = new SkiaSharp.gr_backendtexture_get_gl_textureinfo_0_Return(); + retStruct.glInfo = SkiaSharp.GRGlTextureInfo.unmarshal(glInfo, CanvasKit); + if (SkiaSharp.ApiOverride.gr_backendtexture_get_gl_textureinfo_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendtexture_get_gl_textureinfo_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_backendrendertarget_new_gl_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_backendrendertarget_new_gl_0_Return(); + var parms = SkiaSharp.gr_backendrendertarget_new_gl_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_new_gl_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_new_gl_0_Pre(parms); + } + var width = parms.width; + var height = parms.height; + var samples = parms.samples; + var stencils = parms.stencils; + var glInfo = parms.glInfo.marshalNew(CanvasKit); + var ret = CanvasKit._gr_backendrendertarget_new_gl(width, height, samples, stencils, glInfo); + var retStruct = new SkiaSharp.gr_backendrendertarget_new_gl_0_Return(); + retStruct.glInfo = SkiaSharp.GRGlFramebufferInfo.unmarshal(glInfo, CanvasKit); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_new_gl_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_new_gl_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static gr_backendrendertarget_delete_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_delete_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_delete_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_delete(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_delete_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_delete_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_is_valid_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_is_valid_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_is_valid_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_is_valid_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_is_valid(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_is_valid_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_is_valid_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_width_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_get_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_width_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_width_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_get_width(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_width_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_width_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_height_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_get_height_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_height_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_height_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_get_height(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_height_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_height_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_samples_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_get_samples_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_samples_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_samples_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_get_samples(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_samples_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_samples_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_stencils_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_get_stencils_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_stencils_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_stencils_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_get_stencils(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_stencils_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_stencils_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_backend_0(pParams, pReturn) { + var parms = SkiaSharp.gr_backendrendertarget_get_backend_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_backend_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_backend_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var ret = CanvasKit._gr_backendrendertarget_get_backend(rendertarget); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_backend_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_backend_0_Post(ret, parms); + } + return ret; + } + static gr_backendrendertarget_get_gl_framebufferinfo_0(pParams, pReturn) { + var retStruct = new SkiaSharp.gr_backendrendertarget_get_gl_framebufferinfo_0_Return(); + var parms = SkiaSharp.gr_backendrendertarget_get_gl_framebufferinfo_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_gl_framebufferinfo_0_Pre) { + SkiaSharp.ApiOverride.gr_backendrendertarget_get_gl_framebufferinfo_0_Pre(parms); + } + var rendertarget = parms.rendertarget; + var glInfo = retStruct.glInfo.marshalNew(CanvasKit); + var ret = CanvasKit._gr_backendrendertarget_get_gl_framebufferinfo(rendertarget, glInfo); + var retStruct = new SkiaSharp.gr_backendrendertarget_get_gl_framebufferinfo_0_Return(); + retStruct.glInfo = SkiaSharp.GRGlFramebufferInfo.unmarshal(glInfo, CanvasKit); + if (SkiaSharp.ApiOverride.gr_backendrendertarget_get_gl_framebufferinfo_0_Post) { + ret = SkiaSharp.ApiOverride.gr_backendrendertarget_get_gl_framebufferinfo_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_xmlstreamwriter_new_0(pParams, pReturn) { + var parms = SkiaSharp.sk_xmlstreamwriter_new_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_xmlstreamwriter_new_0_Pre) { + SkiaSharp.ApiOverride.sk_xmlstreamwriter_new_0_Pre(parms); + } + var stream = parms.stream; + var ret = CanvasKit._sk_xmlstreamwriter_new(stream); + if (SkiaSharp.ApiOverride.sk_xmlstreamwriter_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_xmlstreamwriter_new_0_Post(ret, parms); + } + return ret; + } + static sk_xmlstreamwriter_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_xmlstreamwriter_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_xmlstreamwriter_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_xmlstreamwriter_delete_0_Pre(parms); + } + var writer = parms.writer; + var ret = CanvasKit._sk_xmlstreamwriter_delete(writer); + if (SkiaSharp.ApiOverride.sk_xmlstreamwriter_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_xmlstreamwriter_delete_0_Post(ret, parms); + } + return ret; + } + static sk_svgcanvas_create_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_svgcanvas_create_0_Return(); + var parms = SkiaSharp.sk_svgcanvas_create_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_svgcanvas_create_0_Pre) { + SkiaSharp.ApiOverride.sk_svgcanvas_create_0_Pre(parms); + } + var bounds = parms.bounds.marshalNew(CanvasKit); + var writer = parms.writer; + var ret = CanvasKit._sk_svgcanvas_create(bounds, writer); + var retStruct = new SkiaSharp.sk_svgcanvas_create_0_Return(); + retStruct.bounds = SkiaSharp.SKRect.unmarshal(bounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_svgcanvas_create_0_Post) { + ret = SkiaSharp.ApiOverride.sk_svgcanvas_create_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_region_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_region_new(); + if (SkiaSharp.ApiOverride.sk_region_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_new_0_Post(ret); + } + return ret; + } + static sk_region_new2_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_new2_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_new2_0_Pre) { + SkiaSharp.ApiOverride.sk_region_new2_0_Pre(parms); + } + var r = parms.r; + var ret = CanvasKit._sk_region_new2(r); + if (SkiaSharp.ApiOverride.sk_region_new2_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_new2_0_Post(ret, parms); + } + return ret; + } + static sk_region_contains_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_contains_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_contains_0_Pre) { + SkiaSharp.ApiOverride.sk_region_contains_0_Pre(parms); + } + var r = parms.r; + var region = parms.region; + var ret = CanvasKit._sk_region_contains(r, region); + if (SkiaSharp.ApiOverride.sk_region_contains_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_contains_0_Post(ret, parms); + } + return ret; + } + static sk_region_contains2_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_contains2_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_contains2_0_Pre) { + SkiaSharp.ApiOverride.sk_region_contains2_0_Pre(parms); + } + var r = parms.r; + var x = parms.x; + var y = parms.y; + var ret = CanvasKit._sk_region_contains2(r, x, y); + if (SkiaSharp.ApiOverride.sk_region_contains2_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_contains2_0_Post(ret, parms); + } + return ret; + } + static sk_region_intersects_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_intersects_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_intersects_0_Pre) { + SkiaSharp.ApiOverride.sk_region_intersects_0_Pre(parms); + } + var r = parms.r; + var src = parms.src; + var ret = CanvasKit._sk_region_intersects(r, src); + if (SkiaSharp.ApiOverride.sk_region_intersects_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_intersects_0_Post(ret, parms); + } + return ret; + } + static sk_region_intersects_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_region_intersects_rect_0_Return(); + var parms = SkiaSharp.sk_region_intersects_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_intersects_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_region_intersects_rect_0_Pre(parms); + } + var r = parms.r; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_region_intersects_rect(r, rect); + var retStruct = new SkiaSharp.sk_region_intersects_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRectI.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_region_intersects_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_intersects_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_region_set_region_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_set_region_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_set_region_0_Pre) { + SkiaSharp.ApiOverride.sk_region_set_region_0_Pre(parms); + } + var r = parms.r; + var src = parms.src; + var ret = CanvasKit._sk_region_set_region(r, src); + if (SkiaSharp.ApiOverride.sk_region_set_region_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_set_region_0_Post(ret, parms); + } + return ret; + } + static sk_region_set_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_region_set_rect_0_Return(); + var parms = SkiaSharp.sk_region_set_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_set_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_region_set_rect_0_Pre(parms); + } + var r = parms.r; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_region_set_rect(r, rect); + var retStruct = new SkiaSharp.sk_region_set_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRectI.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_region_set_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_set_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_region_set_path_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_set_path_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_set_path_0_Pre) { + SkiaSharp.ApiOverride.sk_region_set_path_0_Pre(parms); + } + var r = parms.r; + var t = parms.t; + var clip = parms.clip; + var ret = CanvasKit._sk_region_set_path(r, t, clip); + if (SkiaSharp.ApiOverride.sk_region_set_path_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_set_path_0_Post(ret, parms); + } + return ret; + } + static sk_region_op_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_op_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_op_0_Pre) { + SkiaSharp.ApiOverride.sk_region_op_0_Pre(parms); + } + var r = parms.r; + var left = parms.left; + var top = parms.top; + var right = parms.right; + var bottom = parms.bottom; + var op = parms.op; + var ret = CanvasKit._sk_region_op(r, left, top, right, bottom, op); + if (SkiaSharp.ApiOverride.sk_region_op_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_op_0_Post(ret, parms); + } + return ret; + } + static sk_region_op2_0(pParams, pReturn) { + var parms = SkiaSharp.sk_region_op2_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_op2_0_Pre) { + SkiaSharp.ApiOverride.sk_region_op2_0_Pre(parms); + } + var r = parms.r; + var src = parms.src; + var op = parms.op; + var ret = CanvasKit._sk_region_op2(r, src, op); + if (SkiaSharp.ApiOverride.sk_region_op2_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_op2_0_Post(ret, parms); + } + return ret; + } + static sk_region_get_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_region_get_bounds_0_Return(); + var parms = SkiaSharp.sk_region_get_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_region_get_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_region_get_bounds_0_Pre(parms); + } + var r = parms.r; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_region_get_bounds(r, rect); + var retStruct = new SkiaSharp.sk_region_get_bounds_0_Return(); + retStruct.rect = SkiaSharp.SKRectI.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_region_get_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_region_get_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_vertices_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_vertices_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_vertices_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_vertices_unref_0_Pre(parms); + } + var cvertices = parms.cvertices; + var ret = CanvasKit._sk_vertices_unref(cvertices); + if (SkiaSharp.ApiOverride.sk_vertices_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_vertices_unref_0_Post(ret, parms); + } + return ret; + } + static sk_vertices_make_copy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_vertices_make_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_vertices_make_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_vertices_make_copy_0_Pre(parms); + } + var vmode = parms.vmode; + var vertexCount = parms.vertexCount; + var positions = parms.positions; + var texs = parms.texs; + var colors = CanvasKit._malloc(parms.colors_Length * 4); + var colors_u32 = colors / 4; + { + for (var i = 0; i < parms.colors_Length; i++) { + CanvasKit.HEAPU32[colors_u32 + i] = parms.colors[i].color; + } + } + var indexCount = parms.indexCount; + var indices = parms.indices; /* ushort */ + var ret = CanvasKit._sk_vertices_make_copy(vmode, vertexCount, positions, texs, colors, indexCount, indices); + if (SkiaSharp.ApiOverride.sk_vertices_make_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_vertices_make_copy_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_rrect_new(); + if (SkiaSharp.ApiOverride.sk_rrect_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_new_0_Post(ret); + } + return ret; + } + static sk_rrect_new_copy_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_new_copy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_new_copy_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_new_copy_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_new_copy(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_new_copy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_new_copy_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_delete_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_delete(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_delete_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_get_type_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_get_type_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_get_type_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_get_type_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_get_type(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_get_type_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_get_type_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_get_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_get_rect_0_Return(); + var parms = SkiaSharp.sk_rrect_get_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_get_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_get_rect_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = retStruct.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_rrect_get_rect(rrect, rect); + var retStruct = new SkiaSharp.sk_rrect_get_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_get_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_get_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_get_radii_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_get_radii_0_Return(); + var parms = SkiaSharp.sk_rrect_get_radii_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_get_radii_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_get_radii_0_Pre(parms); + } + var rrect = parms.rrect; + var corner = parms.corner; + var radii = retStruct.radii.marshalNew(CanvasKit); + var ret = CanvasKit._sk_rrect_get_radii(rrect, corner, radii); + var retStruct = new SkiaSharp.sk_rrect_get_radii_0_Return(); + retStruct.radii = SkiaSharp.SKPoint.unmarshal(radii, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_get_radii_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_get_radii_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_get_width_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_get_width_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_get_width_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_get_width_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_get_width(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_get_width_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_get_width_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_get_height_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_get_height_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_get_height_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_get_height_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_get_height(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_get_height_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_get_height_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_set_empty_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_set_empty_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_empty_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_empty_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_set_empty(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_set_empty_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_empty_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_set_rect_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_set_rect_0_Return(); + var parms = SkiaSharp.sk_rrect_set_rect_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_rect_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_rrect_set_rect(rrect, rect); + var retStruct = new SkiaSharp.sk_rrect_set_rect_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_rect_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_set_oval_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_set_oval_0_Return(); + var parms = SkiaSharp.sk_rrect_set_oval_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_oval_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_oval_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_rrect_set_oval(rrect, rect); + var retStruct = new SkiaSharp.sk_rrect_set_oval_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_set_oval_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_oval_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_set_rect_xy_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_set_rect_xy_0_Return(); + var parms = SkiaSharp.sk_rrect_set_rect_xy_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_xy_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_rect_xy_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var xRad = parms.xRad; + var yRad = parms.yRad; + var ret = CanvasKit._sk_rrect_set_rect_xy(rrect, rect, xRad, yRad); + var retStruct = new SkiaSharp.sk_rrect_set_rect_xy_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_xy_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_rect_xy_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_set_nine_patch_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_set_nine_patch_0_Return(); + var parms = SkiaSharp.sk_rrect_set_nine_patch_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_nine_patch_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_nine_patch_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var leftRad = parms.leftRad; + var topRad = parms.topRad; + var rightRad = parms.rightRad; + var bottomRad = parms.bottomRad; + var ret = CanvasKit._sk_rrect_set_nine_patch(rrect, rect, leftRad, topRad, rightRad, bottomRad); + var retStruct = new SkiaSharp.sk_rrect_set_nine_patch_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_set_nine_patch_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_nine_patch_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_set_rect_radii_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_set_rect_radii_0_Return(); + var parms = SkiaSharp.sk_rrect_set_rect_radii_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_radii_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_set_rect_radii_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var radii = parms.radii; + var ret = CanvasKit._sk_rrect_set_rect_radii(rrect, rect, radii); + var retStruct = new SkiaSharp.sk_rrect_set_rect_radii_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_set_rect_radii_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_set_rect_radii_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_inset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_inset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_inset_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_inset_0_Pre(parms); + } + var rrect = parms.rrect; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_rrect_inset(rrect, dx, dy); + if (SkiaSharp.ApiOverride.sk_rrect_inset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_inset_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_outset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_outset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_outset_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_outset_0_Pre(parms); + } + var rrect = parms.rrect; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_rrect_outset(rrect, dx, dy); + if (SkiaSharp.ApiOverride.sk_rrect_outset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_outset_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_offset_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_offset_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_offset_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_offset_0_Pre(parms); + } + var rrect = parms.rrect; + var dx = parms.dx; + var dy = parms.dy; + var ret = CanvasKit._sk_rrect_offset(rrect, dx, dy); + if (SkiaSharp.ApiOverride.sk_rrect_offset_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_offset_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_contains_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_contains_0_Return(); + var parms = SkiaSharp.sk_rrect_contains_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_contains_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_contains_0_Pre(parms); + } + var rrect = parms.rrect; + var rect = parms.rect.marshalNew(CanvasKit); + var ret = CanvasKit._sk_rrect_contains(rrect, rect); + var retStruct = new SkiaSharp.sk_rrect_contains_0_Return(); + retStruct.rect = SkiaSharp.SKRect.unmarshal(rect, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_contains_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_contains_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_rrect_is_valid_0(pParams, pReturn) { + var parms = SkiaSharp.sk_rrect_is_valid_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_is_valid_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_is_valid_0_Pre(parms); + } + var rrect = parms.rrect; + var ret = CanvasKit._sk_rrect_is_valid(rrect); + if (SkiaSharp.ApiOverride.sk_rrect_is_valid_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_is_valid_0_Post(ret, parms); + } + return ret; + } + static sk_rrect_transform_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_rrect_transform_0_Return(); + var parms = SkiaSharp.sk_rrect_transform_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_rrect_transform_0_Pre) { + SkiaSharp.ApiOverride.sk_rrect_transform_0_Pre(parms); + } + var rrect = parms.rrect; + var matrix = parms.matrix.marshalNew(CanvasKit); + var dest = parms.dest; + var ret = CanvasKit._sk_rrect_transform(rrect, matrix, dest); + var retStruct = new SkiaSharp.sk_rrect_transform_0_Return(); + retStruct.matrix = SkiaSharp.SKMatrix.unmarshal(matrix, CanvasKit); + if (SkiaSharp.ApiOverride.sk_rrect_transform_0_Post) { + ret = SkiaSharp.ApiOverride.sk_rrect_transform_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_ref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_textblob_ref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_ref_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_ref_0_Pre(parms); + } + var blob = parms.blob; + var ret = CanvasKit._sk_textblob_ref(blob); + if (SkiaSharp.ApiOverride.sk_textblob_ref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_ref_0_Post(ret, parms); + } + return ret; + } + static sk_textblob_unref_0(pParams, pReturn) { + var parms = SkiaSharp.sk_textblob_unref_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_unref_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_unref_0_Pre(parms); + } + var blob = parms.blob; + var ret = CanvasKit._sk_textblob_unref(blob); + if (SkiaSharp.ApiOverride.sk_textblob_unref_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_unref_0_Post(ret, parms); + } + return ret; + } + static sk_textblob_get_unique_id_0(pParams, pReturn) { + var parms = SkiaSharp.sk_textblob_get_unique_id_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_get_unique_id_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_get_unique_id_0_Pre(parms); + } + var blob = parms.blob; + var ret = CanvasKit._sk_textblob_get_unique_id(blob); + if (SkiaSharp.ApiOverride.sk_textblob_get_unique_id_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_get_unique_id_0_Post(ret, parms); + } + return ret; + } + static sk_textblob_get_bounds_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_get_bounds_0_Return(); + var parms = SkiaSharp.sk_textblob_get_bounds_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_get_bounds_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_get_bounds_0_Pre(parms); + } + var blob = parms.blob; + var bounds = retStruct.bounds.marshalNew(CanvasKit); + var ret = CanvasKit._sk_textblob_get_bounds(blob, bounds); + var retStruct = new SkiaSharp.sk_textblob_get_bounds_0_Return(); + retStruct.bounds = SkiaSharp.SKRect.unmarshal(bounds, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_get_bounds_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_get_bounds_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_new_0(pParams, pReturn) { + var ret = CanvasKit._sk_textblob_builder_new(); + if (SkiaSharp.ApiOverride.sk_textblob_builder_new_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_new_0_Post(ret); + } + return ret; + } + static sk_textblob_builder_delete_0(pParams, pReturn) { + var parms = SkiaSharp.sk_textblob_builder_delete_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_delete_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_delete_0_Pre(parms); + } + var builder = parms.builder; + var ret = CanvasKit._sk_textblob_builder_delete(builder); + if (SkiaSharp.ApiOverride.sk_textblob_builder_delete_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_delete_0_Post(ret, parms); + } + return ret; + } + static sk_textblob_builder_make_0(pParams, pReturn) { + var parms = SkiaSharp.sk_textblob_builder_make_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_make_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_make_0_Pre(parms); + } + var builder = parms.builder; + var ret = CanvasKit._sk_textblob_builder_make(builder); + if (SkiaSharp.ApiOverride.sk_textblob_builder_make_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_make_0_Post(ret, parms); + } + return ret; + } + static sk_textblob_builder_alloc_run_text_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_alloc_run_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_0_Pre(parms); + } + var builder = parms.builder; + var font = parms.font; + var count = parms.count; + var x = parms.x; + var y = parms.y; + var textByteCount = parms.textByteCount; + var lang = parms.lang; + var bounds = parms.bounds; + var runbuffer = retStruct.runbuffer.marshalNew(CanvasKit); + var ret = CanvasKit._sk_textblob_builder_alloc_run_text(builder, font, count, x, y, textByteCount, lang, bounds, runbuffer); + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_0_Return(); + retStruct.runbuffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(runbuffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_alloc_run_text_pos_h_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_pos_h_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_alloc_run_text_pos_h_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_h_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_h_0_Pre(parms); + } + var builder = parms.builder; + var font = parms.font; + var count = parms.count; + var y = parms.y; + var textByteCount = parms.textByteCount; + var lang = parms.lang; + var bounds = parms.bounds; + var runbuffer = retStruct.runbuffer.marshalNew(CanvasKit); + var ret = CanvasKit._sk_textblob_builder_alloc_run_text_pos_h(builder, font, count, y, textByteCount, lang, bounds, runbuffer); + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_pos_h_0_Return(); + retStruct.runbuffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(runbuffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_h_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_h_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_alloc_run_text_pos_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_pos_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_alloc_run_text_pos_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_0_Pre(parms); + } + var builder = parms.builder; + var font = parms.font; + var count = parms.count; + var textByteCount = parms.textByteCount; + var lang = parms.lang; + var bounds = parms.bounds; + var runbuffer = retStruct.runbuffer.marshalNew(CanvasKit); + var ret = CanvasKit._sk_textblob_builder_alloc_run_text_pos(builder, font, count, textByteCount, lang, bounds, runbuffer); + var retStruct = new SkiaSharp.sk_textblob_builder_alloc_run_text_pos_0_Return(); + retStruct.runbuffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(runbuffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_alloc_run_text_pos_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_runbuffer_set_glyphs_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_glyphs_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_runbuffer_set_glyphs_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_glyphs_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_glyphs_0_Pre(parms); + } + var buffer = parms.buffer.marshalNew(CanvasKit); + var glyphs = parms.glyphs; + var count = parms.count; + var ret = CanvasKit._sk_textblob_builder_runbuffer_set_glyphs(buffer, glyphs, count); + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_glyphs_0_Return(); + retStruct.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(buffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_glyphs_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_glyphs_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_runbuffer_set_pos_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_pos_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_runbuffer_set_pos_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_0_Pre(parms); + } + var buffer = parms.buffer.marshalNew(CanvasKit); + var pos = parms.pos; + var count = parms.count; + var ret = CanvasKit._sk_textblob_builder_runbuffer_set_pos(buffer, pos, count); + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_pos_0_Return(); + retStruct.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(buffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_runbuffer_set_pos_points_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_pos_points_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_runbuffer_set_pos_points_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_points_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_points_0_Pre(parms); + } + var buffer = parms.buffer.marshalNew(CanvasKit); + var pos = parms.pos; + var count = parms.count; + var ret = CanvasKit._sk_textblob_builder_runbuffer_set_pos_points(buffer, pos, count); + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_pos_points_0_Return(); + retStruct.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(buffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_points_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_pos_points_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_runbuffer_set_utf8_text_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_utf8_text_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_runbuffer_set_utf8_text_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_utf8_text_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_utf8_text_0_Pre(parms); + } + var buffer = parms.buffer.marshalNew(CanvasKit); + var text = parms.text; + var count = parms.count; + var ret = CanvasKit._sk_textblob_builder_runbuffer_set_utf8_text(buffer, text, count); + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_utf8_text_0_Return(); + retStruct.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(buffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_utf8_text_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_utf8_text_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + static sk_textblob_builder_runbuffer_set_clusters_0(pParams, pReturn) { + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_clusters_0_Return(); + var parms = SkiaSharp.sk_textblob_builder_runbuffer_set_clusters_0_Params.unmarshal(pParams); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_clusters_0_Pre) { + SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_clusters_0_Pre(parms); + } + var buffer = parms.buffer.marshalNew(CanvasKit); + var clusters = parms.clusters; + var count = parms.count; + var ret = CanvasKit._sk_textblob_builder_runbuffer_set_clusters(buffer, clusters, count); + var retStruct = new SkiaSharp.sk_textblob_builder_runbuffer_set_clusters_0_Return(); + retStruct.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(buffer, CanvasKit); + if (SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_clusters_0_Post) { + ret = SkiaSharp.ApiOverride.sk_textblob_builder_runbuffer_set_clusters_0_Post(ret, parms, retStruct); + } + retStruct.marshal(pReturn); + return ret; + } + } + SkiaSharp.SkiaApi = SkiaApi; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_delete_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_delete_0_Params = gr_backendrendertarget_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_backend_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_backend_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_backend_0_Params = gr_backendrendertarget_get_backend_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_gl_framebufferinfo_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_gl_framebufferinfo_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_gl_framebufferinfo_0_Params = gr_backendrendertarget_get_gl_framebufferinfo_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_gl_framebufferinfo_0_Return { + constructor() { + this.glInfo = new SkiaSharp.GRGlFramebufferInfo(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.glInfo.marshal(pData + 0); + } + } + SkiaSharp.gr_backendrendertarget_get_gl_framebufferinfo_0_Return = gr_backendrendertarget_get_gl_framebufferinfo_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_height_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_height_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_height_0_Params = gr_backendrendertarget_get_height_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_samples_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_samples_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_samples_0_Params = gr_backendrendertarget_get_samples_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_stencils_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_stencils_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_stencils_0_Params = gr_backendrendertarget_get_stencils_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_get_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_get_width_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_get_width_0_Params = gr_backendrendertarget_get_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_is_valid_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_is_valid_0_Params(); + { + ret.rendertarget = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_is_valid_0_Params = gr_backendrendertarget_is_valid_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_new_gl_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendrendertarget_new_gl_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.samples = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.stencils = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.glInfo = SkiaSharp.GRGlFramebufferInfo.unmarshal(pData + 16); + } + return ret; + } + } + SkiaSharp.gr_backendrendertarget_new_gl_0_Params = gr_backendrendertarget_new_gl_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendrendertarget_new_gl_0_Return { + constructor() { + this.glInfo = new SkiaSharp.GRGlFramebufferInfo(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.glInfo.marshal(pData + 0); + } + } + SkiaSharp.gr_backendrendertarget_new_gl_0_Return = gr_backendrendertarget_new_gl_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_delete_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_delete_0_Params = gr_backendtexture_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_get_backend_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_get_backend_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_get_backend_0_Params = gr_backendtexture_get_backend_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_get_gl_textureinfo_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_get_gl_textureinfo_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_get_gl_textureinfo_0_Params = gr_backendtexture_get_gl_textureinfo_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_get_gl_textureinfo_0_Return { + constructor() { + this.glInfo = new SkiaSharp.GRGlTextureInfo(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.glInfo.marshal(pData + 0); + } + } + SkiaSharp.gr_backendtexture_get_gl_textureinfo_0_Return = gr_backendtexture_get_gl_textureinfo_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_get_height_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_get_height_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_get_height_0_Params = gr_backendtexture_get_height_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_get_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_get_width_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_get_width_0_Params = gr_backendtexture_get_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_has_mipmaps_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_has_mipmaps_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_has_mipmaps_0_Params = gr_backendtexture_has_mipmaps_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_is_valid_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_is_valid_0_Params(); + { + ret.texture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_is_valid_0_Params = gr_backendtexture_is_valid_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_new_gl_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_backendtexture_new_gl_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.mipmapped = Boolean(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.glInfo = SkiaSharp.GRGlTextureInfo.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.gr_backendtexture_new_gl_0_Params = gr_backendtexture_new_gl_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_backendtexture_new_gl_0_Return { + constructor() { + this.glInfo = new SkiaSharp.GRGlTextureInfo(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.glInfo.marshal(pData + 0); + } + } + SkiaSharp.gr_backendtexture_new_gl_0_Return = gr_backendtexture_new_gl_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_abandon_context_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_abandon_context_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_abandon_context_0_Params = gr_context_abandon_context_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_flush_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_flush_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_flush_0_Params = gr_context_flush_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_backend_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_get_backend_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_get_backend_0_Params = gr_context_get_backend_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_max_surface_sample_count_for_color_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_get_max_surface_sample_count_for_color_type_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.gr_context_get_max_surface_sample_count_for_color_type_0_Params = gr_context_get_max_surface_sample_count_for_color_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_resource_cache_limits_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_get_resource_cache_limits_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_get_resource_cache_limits_0_Params = gr_context_get_resource_cache_limits_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_resource_cache_limits_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.maxResources, "i32"); + memoryContext.setValue(pData + 4, this.maxResourceBytes, "*"); + } + } + SkiaSharp.gr_context_get_resource_cache_limits_0_Return = gr_context_get_resource_cache_limits_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_resource_cache_usage_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_get_resource_cache_usage_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_get_resource_cache_usage_0_Params = gr_context_get_resource_cache_usage_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_get_resource_cache_usage_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.maxResources, "i32"); + memoryContext.setValue(pData + 4, this.maxResourceBytes, "*"); + } + } + SkiaSharp.gr_context_get_resource_cache_usage_0_Return = gr_context_get_resource_cache_usage_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_make_gl_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_make_gl_0_Params(); + { + ret.glInterface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_make_gl_0_Params = gr_context_make_gl_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_release_resources_and_abandon_context_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_release_resources_and_abandon_context_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_release_resources_and_abandon_context_0_Params = gr_context_release_resources_and_abandon_context_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_reset_context_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_reset_context_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.state = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.gr_context_reset_context_0_Params = gr_context_reset_context_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_set_resource_cache_limits_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_set_resource_cache_limits_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.maxResources = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.maxResourceBytes = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_set_resource_cache_limits_0_Params = gr_context_set_resource_cache_limits_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_context_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_context_unref_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_context_unref_0_Params = gr_context_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_assemble_gl_interface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_assemble_gl_interface_0_Params(); + { + ret.ctx = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.get = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.gr_glinterface_assemble_gl_interface_0_Params = gr_glinterface_assemble_gl_interface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_assemble_gles_interface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_assemble_gles_interface_0_Params(); + { + ret.ctx = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.get = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.gr_glinterface_assemble_gles_interface_0_Params = gr_glinterface_assemble_gles_interface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_assemble_interface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_assemble_interface_0_Params(); + { + ret.ctx = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.get = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.gr_glinterface_assemble_interface_0_Params = gr_glinterface_assemble_interface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_has_extension_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_has_extension_0_Params(); + { + ret.glInterface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.extension = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.extension = null; + } + } + return ret; + } + } + SkiaSharp.gr_glinterface_has_extension_0_Params = gr_glinterface_has_extension_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_unref_0_Params(); + { + ret.glInterface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_glinterface_unref_0_Params = gr_glinterface_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class gr_glinterface_validate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new gr_glinterface_validate_0_Params(); + { + ret.glInterface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.gr_glinterface_validate_0_Params = gr_glinterface_validate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_apply_to_canvas_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_apply_to_canvas_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.ccanvas = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_3dview_apply_to_canvas_0_Params = sk_3dview_apply_to_canvas_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_destroy_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_3dview_destroy_0_Params = sk_3dview_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_dot_with_normal_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_dot_with_normal_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_dot_with_normal_0_Params = sk_3dview_dot_with_normal_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_get_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_get_matrix_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cmatrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_3dview_get_matrix_0_Params = sk_3dview_get_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_get_matrix_0_Return { + constructor() { + this.cmatrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmatrix.marshal(pData + 0); + } + } + SkiaSharp.sk_3dview_get_matrix_0_Return = sk_3dview_get_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_restore_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_restore_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_3dview_restore_0_Params = sk_3dview_restore_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_x_degrees_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_x_degrees_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.degrees = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_x_degrees_0_Params = sk_3dview_rotate_x_degrees_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_x_radians_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_x_radians_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_x_radians_0_Params = sk_3dview_rotate_x_radians_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_y_degrees_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_y_degrees_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.degrees = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_y_degrees_0_Params = sk_3dview_rotate_y_degrees_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_y_radians_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_y_radians_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_y_radians_0_Params = sk_3dview_rotate_y_radians_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_z_degrees_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_z_degrees_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.degrees = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_z_degrees_0_Params = sk_3dview_rotate_z_degrees_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_rotate_z_radians_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_rotate_z_radians_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_rotate_z_radians_0_Params = sk_3dview_rotate_z_radians_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_save_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_save_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_3dview_save_0_Params = sk_3dview_save_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_3dview_translate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_3dview_translate_0_Params(); + { + ret.cview = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.z = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_3dview_translate_0_Params = sk_3dview_translate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_destructor_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_destructor_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_destructor_0_Params = sk_bitmap_destructor_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_erase_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_erase_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_bitmap_erase_0_Params = sk_bitmap_erase_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_erase_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_erase_rect_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 4); + } + { + ret.rect = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_bitmap_erase_rect_0_Params = sk_bitmap_erase_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_erase_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_erase_rect_0_Return = sk_bitmap_erase_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_extract_alpha_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_extract_alpha_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_extract_alpha_0_Params = sk_bitmap_extract_alpha_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_extract_alpha_0_Return { + constructor() { + this.offset = new SkiaSharp.SKPointI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.offset.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_extract_alpha_0_Return = sk_bitmap_extract_alpha_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_extract_subset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_extract_subset_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cdst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_bitmap_extract_subset_0_Params = sk_bitmap_extract_subset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_extract_subset_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_extract_subset_0_Return = sk_bitmap_extract_subset_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_addr_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_addr_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_addr_0_Params = sk_bitmap_get_addr_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_addr_16_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_addr_16_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_addr_16_0_Params = sk_bitmap_get_addr_16_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_addr_32_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_addr_32_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_addr_32_0_Params = sk_bitmap_get_addr_32_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_addr_8_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_addr_8_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_addr_8_0_Params = sk_bitmap_get_addr_8_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_byte_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_byte_count_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_byte_count_0_Params = sk_bitmap_get_byte_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_info_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_info_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_info_0_Params = sk_bitmap_get_info_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_info_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_get_info_0_Return = sk_bitmap_get_info_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_pixel_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_pixel_color_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_pixel_color_0_Params = sk_bitmap_get_pixel_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_pixel_colors_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_pixel_colors_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_pixel_colors_0_Params = sk_bitmap_get_pixel_colors_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_pixels_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_pixels_0_Params = sk_bitmap_get_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_pixels_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.length, "*"); + } + } + SkiaSharp.sk_bitmap_get_pixels_0_Return = sk_bitmap_get_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_get_row_bytes_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_get_row_bytes_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_get_row_bytes_0_Params = sk_bitmap_get_row_bytes_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_install_mask_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_install_mask_pixels_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_bitmap_install_mask_pixels_0_Params = sk_bitmap_install_mask_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_install_mask_pixels_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_install_mask_pixels_0_Return = sk_bitmap_install_mask_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_install_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_install_pixels_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.releaseProc = Number(memoryContext.getValue(pData + 32, "*")); + } + { + ret.context = Number(memoryContext.getValue(pData + 36, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_install_pixels_0_Params = sk_bitmap_install_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_install_pixels_0_Return { + constructor() { + this.cinfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cinfo.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_install_pixels_0_Return = sk_bitmap_install_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_install_pixels_with_pixmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_install_pixels_with_pixmap_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cpixmap = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_install_pixels_with_pixmap_0_Params = sk_bitmap_install_pixels_with_pixmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_is_immutable_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_is_immutable_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_is_immutable_0_Params = sk_bitmap_is_immutable_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_is_null_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_is_null_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_is_null_0_Params = sk_bitmap_is_null_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_is_volatile_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_is_volatile_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_is_volatile_0_Params = sk_bitmap_is_volatile_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_notify_pixels_changed_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_notify_pixels_changed_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_notify_pixels_changed_0_Params = sk_bitmap_notify_pixels_changed_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_peek_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_peek_pixels_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cpixmap = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_peek_pixels_0_Params = sk_bitmap_peek_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_ready_to_draw_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_ready_to_draw_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_ready_to_draw_0_Params = sk_bitmap_ready_to_draw_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_reset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_reset_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_reset_0_Params = sk_bitmap_reset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_set_immutable_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_set_immutable_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_set_immutable_0_Params = sk_bitmap_set_immutable_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_set_pixel_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_set_pixel_color_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.sk_bitmap_set_pixel_color_0_Params = sk_bitmap_set_pixel_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_set_pixel_colors_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_set_pixel_colors_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + return ret; + } + } + SkiaSharp.sk_bitmap_set_pixel_colors_0_Params = sk_bitmap_set_pixel_colors_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_set_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_set_pixels_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_set_pixels_0_Params = sk_bitmap_set_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_set_volatile_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_set_volatile_0_Params(); + { + ret.b = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_set_volatile_0_Params = sk_bitmap_set_volatile_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_swap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_swap_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cother = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_swap_0_Params = sk_bitmap_swap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_try_alloc_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_try_alloc_pixels_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.requestedInfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_try_alloc_pixels_0_Params = sk_bitmap_try_alloc_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_try_alloc_pixels_0_Return { + constructor() { + this.requestedInfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.requestedInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_try_alloc_pixels_0_Return = sk_bitmap_try_alloc_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_try_alloc_pixels_with_flags_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_bitmap_try_alloc_pixels_with_flags_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.requestedInfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.flags = Number(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + } + SkiaSharp.sk_bitmap_try_alloc_pixels_with_flags_0_Params = sk_bitmap_try_alloc_pixels_with_flags_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_bitmap_try_alloc_pixels_with_flags_0_Return { + constructor() { + this.requestedInfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.requestedInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_bitmap_try_alloc_pixels_with_flags_0_Return = sk_bitmap_try_alloc_pixels_with_flags_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_clip_path_with_operation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_clip_path_with_operation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cpath = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.doAA = Boolean(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_clip_path_with_operation_0_Params = sk_canvas_clip_path_with_operation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_clip_rect_with_operation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_clip_rect_with_operation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.crect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.op = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.doAA = Boolean(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_clip_rect_with_operation_0_Params = sk_canvas_clip_rect_with_operation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_clip_rect_with_operation_0_Return { + constructor() { + this.crect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.crect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_clip_rect_with_operation_0_Return = sk_canvas_clip_rect_with_operation_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_clip_region_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_clip_region_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.region = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_clip_region_0_Params = sk_canvas_clip_region_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_clip_rrect_with_operation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_clip_rrect_with_operation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.crect = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.doAA = Boolean(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_clip_rrect_with_operation_0_Params = sk_canvas_clip_rrect_with_operation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_concat_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.m = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_canvas_concat_0_Params = sk_canvas_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_concat_0_Return { + constructor() { + this.m = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.m.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_concat_0_Return = sk_canvas_concat_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_destroy_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_destroy_0_Params = sk_canvas_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_annotation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_annotation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.key_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.key = new Array(); + for (var i = 0; i < ret.key_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.key.push(Number(value)); + } + } + else { + ret.key = null; + } + } + { + ret.value = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_annotation_0_Params = sk_canvas_draw_annotation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_annotation_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_annotation_0_Return = sk_canvas_draw_annotation_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_bitmap_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bitmap = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_bitmap_0_Params = sk_canvas_draw_bitmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_lattice_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_bitmap_lattice_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bitmap = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.lattice = SkiaSharp.SKLatticeInternal.unmarshal(pData + 8); + } + { + ret.dst = SkiaSharp.SKRect.unmarshal(pData + 36); + } + { + ret.paint = Number(memoryContext.getValue(pData + 52, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_bitmap_lattice_0_Params = sk_canvas_draw_bitmap_lattice_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_lattice_0_Return { + constructor() { + this.lattice = new SkiaSharp.SKLatticeInternal(); + this.dst = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.lattice.marshal(pData + 0); + this.dst.marshal(pData + 28); + } + } + SkiaSharp.sk_canvas_draw_bitmap_lattice_0_Return = sk_canvas_draw_bitmap_lattice_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_nine_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_bitmap_nine_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bitmap = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.center = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + { + ret.dst = SkiaSharp.SKRect.unmarshal(pData + 24); + } + { + ret.paint = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_bitmap_nine_0_Params = sk_canvas_draw_bitmap_nine_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_nine_0_Return { + constructor() { + this.center = new SkiaSharp.SKRectI(); + this.dst = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.dst.marshal(pData + 16); + } + } + SkiaSharp.sk_canvas_draw_bitmap_nine_0_Return = sk_canvas_draw_bitmap_nine_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_bitmap_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bitmap = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.src = SkiaSharp.SKRect.unmarshal(pData + 8); + } + { + ret.dest = SkiaSharp.SKRect.unmarshal(pData + 24); + } + { + ret.paint = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_bitmap_rect_0_Params = sk_canvas_draw_bitmap_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_rect_0_Return { + constructor() { + this.src = new SkiaSharp.SKRect(); + this.dest = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.src.marshal(pData + 0); + this.dest.marshal(pData + 16); + } + } + SkiaSharp.sk_canvas_draw_bitmap_rect_0_Return = sk_canvas_draw_bitmap_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_rect_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_bitmap_rect_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bitmap = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.srcZero = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.dest = SkiaSharp.SKRect.unmarshal(pData + 12); + } + { + ret.paint = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_bitmap_rect_1_Params = sk_canvas_draw_bitmap_rect_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_bitmap_rect_1_Return { + constructor() { + this.dest = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dest.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_bitmap_rect_1_Return = sk_canvas_draw_bitmap_rect_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_circle_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_circle_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.cy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.radius = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_circle_0_Params = sk_canvas_draw_circle_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_color_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 4); + } + { + ret.mode = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_color_0_Params = sk_canvas_draw_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_drawable_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_drawable_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.drawable = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.mat = SkiaSharp.SKMatrix.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_drawable_0_Params = sk_canvas_draw_drawable_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_drawable_0_Return { + constructor() { + this.mat = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.mat.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_drawable_0_Return = sk_canvas_draw_drawable_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_image_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.image = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_image_0_Params = sk_canvas_draw_image_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_lattice_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_image_lattice_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.image = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.lattice = SkiaSharp.SKLatticeInternal.unmarshal(pData + 8); + } + { + ret.dst = SkiaSharp.SKRect.unmarshal(pData + 36); + } + { + ret.paint = Number(memoryContext.getValue(pData + 52, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_image_lattice_0_Params = sk_canvas_draw_image_lattice_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_lattice_0_Return { + constructor() { + this.lattice = new SkiaSharp.SKLatticeInternal(); + this.dst = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.lattice.marshal(pData + 0); + this.dst.marshal(pData + 28); + } + } + SkiaSharp.sk_canvas_draw_image_lattice_0_Return = sk_canvas_draw_image_lattice_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_nine_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_image_nine_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.image = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.center = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + { + ret.dst = SkiaSharp.SKRect.unmarshal(pData + 24); + } + { + ret.paint = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_image_nine_0_Params = sk_canvas_draw_image_nine_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_nine_0_Return { + constructor() { + this.center = new SkiaSharp.SKRectI(); + this.dst = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.dst.marshal(pData + 16); + } + } + SkiaSharp.sk_canvas_draw_image_nine_0_Return = sk_canvas_draw_image_nine_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_image_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.image = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.src = SkiaSharp.SKRect.unmarshal(pData + 8); + } + { + ret.dest = SkiaSharp.SKRect.unmarshal(pData + 24); + } + { + ret.paint = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_image_rect_0_Params = sk_canvas_draw_image_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_rect_0_Return { + constructor() { + this.src = new SkiaSharp.SKRect(); + this.dest = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.src.marshal(pData + 0); + this.dest.marshal(pData + 16); + } + } + SkiaSharp.sk_canvas_draw_image_rect_0_Return = sk_canvas_draw_image_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_rect_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_image_rect_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.image = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.srcZero = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.dest = SkiaSharp.SKRect.unmarshal(pData + 12); + } + { + ret.paint = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_image_rect_1_Params = sk_canvas_draw_image_rect_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_image_rect_1_Return { + constructor() { + this.dest = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dest.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_image_rect_1_Return = sk_canvas_draw_image_rect_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_line_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_line_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.x1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y1 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_line_0_Params = sk_canvas_draw_line_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_link_destination_annotation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_link_destination_annotation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.value = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_link_destination_annotation_0_Params = sk_canvas_draw_link_destination_annotation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_link_destination_annotation_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_link_destination_annotation_0_Return = sk_canvas_draw_link_destination_annotation_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_named_destination_annotation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_named_destination_annotation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.point = SkiaSharp.SKPoint.unmarshal(pData + 4); + } + { + ret.value = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_named_destination_annotation_0_Params = sk_canvas_draw_named_destination_annotation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_named_destination_annotation_0_Return { + constructor() { + this.point = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.point.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_named_destination_annotation_0_Return = sk_canvas_draw_named_destination_annotation_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_oval_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_oval_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_oval_0_Params = sk_canvas_draw_oval_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_oval_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_oval_0_Return = sk_canvas_draw_oval_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_paint_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_paint_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.p = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_paint_0_Params = sk_canvas_draw_paint_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_path_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.path = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_path_0_Params = sk_canvas_draw_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_picture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_picture_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pict = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.mat = SkiaSharp.SKMatrix.unmarshal(pData + 8); + } + { + ret.paint = Number(memoryContext.getValue(pData + 44, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_picture_0_Params = sk_canvas_draw_picture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_picture_0_Return { + constructor() { + this.mat = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.mat.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_picture_0_Return = sk_canvas_draw_picture_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_picture_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_picture_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pict = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.matZero = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_picture_1_Params = sk_canvas_draw_picture_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_point_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_point_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_point_0_Params = sk_canvas_draw_point_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_points_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_points_0_Params = sk_canvas_draw_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_pos_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_pos_text_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.text = new Array(); + for (var i = 0; i < ret.text_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.text.push(Number(value)); + } + } + else { + ret.text = null; + } + } + { + ret.len = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.paint = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_pos_text_0_Params = sk_canvas_draw_pos_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_pos_text_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_pos_text_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.len = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_pos_text_1_Params = sk_canvas_draw_pos_text_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_rect_0_Params = sk_canvas_draw_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_rect_0_Return = sk_canvas_draw_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_region_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_region_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.region = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_region_0_Params = sk_canvas_draw_region_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_round_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_round_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.rx = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.ry = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_round_rect_0_Params = sk_canvas_draw_round_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_round_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_round_rect_0_Return = sk_canvas_draw_round_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_rrect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_rrect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_rrect_0_Params = sk_canvas_draw_rrect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_text_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.text = new Array(); + for (var i = 0; i < ret.text_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.text.push(Number(value)); + } + } + else { + ret.text = null; + } + } + { + ret.len = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.x = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_text_0_Params = sk_canvas_draw_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_text_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_text_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.len = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.x = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_text_1_Params = sk_canvas_draw_text_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_text_blob_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_text_blob_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_text_blob_0_Params = sk_canvas_draw_text_blob_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_text_on_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_text_on_path_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.text = new Array(); + for (var i = 0; i < ret.text_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.text.push(Number(value)); + } + } + else { + ret.text = null; + } + } + { + ret.len = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.path = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.hOffset = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.vOffset = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_text_on_path_0_Params = sk_canvas_draw_text_on_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_text_on_path_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_text_on_path_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.len = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.path = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.hOffset = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.vOffset = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_text_on_path_1_Params = sk_canvas_draw_text_on_path_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_url_annotation_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_url_annotation_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.value = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_url_annotation_0_Params = sk_canvas_draw_url_annotation_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_url_annotation_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_draw_url_annotation_0_Return = sk_canvas_draw_url_annotation_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_draw_vertices_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_draw_vertices_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.vertices = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_draw_vertices_0_Params = sk_canvas_draw_vertices_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_flush_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_flush_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_flush_0_Params = sk_canvas_flush_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_device_clip_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_get_device_clip_bounds_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_get_device_clip_bounds_0_Params = sk_canvas_get_device_clip_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_device_clip_bounds_0_Return { + constructor() { + this.cbounds = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cbounds.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_get_device_clip_bounds_0_Return = sk_canvas_get_device_clip_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_local_clip_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_get_local_clip_bounds_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_get_local_clip_bounds_0_Params = sk_canvas_get_local_clip_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_local_clip_bounds_0_Return { + constructor() { + this.cbounds = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cbounds.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_get_local_clip_bounds_0_Return = sk_canvas_get_local_clip_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_save_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_get_save_count_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_get_save_count_0_Params = sk_canvas_get_save_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_total_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_get_total_matrix_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_canvas_get_total_matrix_0_Params = sk_canvas_get_total_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_get_total_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_get_total_matrix_0_Return = sk_canvas_get_total_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_new_from_bitmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_new_from_bitmap_0_Params(); + { + ret.bitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_new_from_bitmap_0_Params = sk_canvas_new_from_bitmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_quick_reject_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_quick_reject_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_canvas_quick_reject_0_Params = sk_canvas_quick_reject_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_quick_reject_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_quick_reject_0_Return = sk_canvas_quick_reject_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_reset_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_reset_matrix_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_reset_matrix_0_Params = sk_canvas_reset_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_restore_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_restore_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_restore_0_Params = sk_canvas_restore_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_restore_to_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_restore_to_count_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.saveCount = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_canvas_restore_to_count_0_Params = sk_canvas_restore_to_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_rotate_degrees_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_rotate_degrees_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.degrees = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_canvas_rotate_degrees_0_Params = sk_canvas_rotate_degrees_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_rotate_radians_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_rotate_radians_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_canvas_rotate_radians_0_Params = sk_canvas_rotate_radians_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_save_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_save_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_save_0_Params = sk_canvas_save_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_save_layer_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_save_layer_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.paint = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_save_layer_0_Params = sk_canvas_save_layer_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_save_layer_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_save_layer_0_Return = sk_canvas_save_layer_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_save_layer_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_save_layer_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rectZero = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_canvas_save_layer_1_Params = sk_canvas_save_layer_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_scale_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_scale_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.sx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_canvas_scale_0_Params = sk_canvas_scale_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_set_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_set_matrix_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_canvas_set_matrix_0_Params = sk_canvas_set_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_set_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_canvas_set_matrix_0_Return = sk_canvas_set_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_skew_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_skew_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.sx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_canvas_skew_0_Params = sk_canvas_skew_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_canvas_translate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_canvas_translate_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_canvas_translate_0_Params = sk_canvas_translate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_destroy_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_destroy_0_Params = sk_codec_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_encoded_format_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_encoded_format_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_encoded_format_0_Params = sk_codec_get_encoded_format_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_frame_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_frame_count_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_frame_count_0_Params = sk_codec_get_frame_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_frame_info_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_frame_info_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.frameInfo_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKCodecFrameInfo 4 False*/ + if (pArray !== 0) { + ret.frameInfo = new Array(); + for (var i = 0; i < ret.frameInfo_Length; i++) { + ret.frameInfo.push(SkiaSharp.SKCodecFrameInfo.unmarshal(pArray + i * 4)); + } + } + else { + ret.frameInfo = null; + } + } + return ret; + } + } + SkiaSharp.sk_codec_get_frame_info_0_Params = sk_codec_get_frame_info_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_frame_info_for_index_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_frame_info_for_index_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_frame_info_for_index_0_Params = sk_codec_get_frame_info_for_index_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_frame_info_for_index_0_Return { + constructor() { + this.frameInfo = new SkiaSharp.SKCodecFrameInfo(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.frameInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_get_frame_info_for_index_0_Return = sk_codec_get_frame_info_for_index_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_info_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_info_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_info_0_Params = sk_codec_get_info_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_info_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_get_info_0_Return = sk_codec_get_info_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_origin_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_origin_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_origin_0_Params = sk_codec_get_origin_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_pixels_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(pData + 32); + } + return ret; + } + } + SkiaSharp.sk_codec_get_pixels_0_Params = sk_codec_get_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_pixels_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + this.options = new SkiaSharp.SKCodecOptionsInternal(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(40); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + this.options.marshal(pData + 20); + } + } + SkiaSharp.sk_codec_get_pixels_0_Return = sk_codec_get_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_repetition_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_repetition_count_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_repetition_count_0_Params = sk_codec_get_repetition_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_scaled_dimensions_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_scaled_dimensions_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.desiredScale = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_scaled_dimensions_0_Params = sk_codec_get_scaled_dimensions_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_scaled_dimensions_0_Return { + constructor() { + this.dimensions = new SkiaSharp.SKSizeI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dimensions.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_get_scaled_dimensions_0_Return = sk_codec_get_scaled_dimensions_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_scanline_order_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_scanline_order_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_scanline_order_0_Params = sk_codec_get_scanline_order_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_scanlines_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_scanlines_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.countLines = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_get_scanlines_0_Params = sk_codec_get_scanlines_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_valid_subset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_get_valid_subset_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.desiredSubset = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_codec_get_valid_subset_0_Params = sk_codec_get_valid_subset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_get_valid_subset_0_Return { + constructor() { + this.desiredSubset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.desiredSubset.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_get_valid_subset_0_Return = sk_codec_get_valid_subset_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_incremental_decode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_incremental_decode_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_incremental_decode_0_Params = sk_codec_incremental_decode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_incremental_decode_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.rowsDecoded, "i32"); + } + } + SkiaSharp.sk_codec_incremental_decode_0_Return = sk_codec_incremental_decode_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_new_from_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_new_from_data_0_Params(); + { + ret.data = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_new_from_data_0_Params = sk_codec_new_from_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_new_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_new_from_stream_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_new_from_stream_0_Params = sk_codec_new_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_new_from_stream_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.result, "i32"); + } + } + SkiaSharp.sk_codec_new_from_stream_0_Return = sk_codec_new_from_stream_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_next_scanline_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_next_scanline_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_next_scanline_0_Params = sk_codec_next_scanline_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_output_scanline_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_output_scanline_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.inputScanline = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_codec_output_scanline_0_Params = sk_codec_output_scanline_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_skip_scanlines_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_skip_scanlines_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.countLines = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_codec_skip_scanlines_0_Params = sk_codec_skip_scanlines_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_incremental_decode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_start_incremental_decode_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(pData + 32); + } + return ret; + } + } + SkiaSharp.sk_codec_start_incremental_decode_0_Params = sk_codec_start_incremental_decode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_incremental_decode_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + this.options = new SkiaSharp.SKCodecOptionsInternal(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(40); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + this.options.marshal(pData + 20); + } + } + SkiaSharp.sk_codec_start_incremental_decode_0_Return = sk_codec_start_incremental_decode_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_incremental_decode_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_start_incremental_decode_1_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.optionsZero = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_start_incremental_decode_1_Params = sk_codec_start_incremental_decode_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_incremental_decode_1_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_start_incremental_decode_1_Return = sk_codec_start_incremental_decode_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_scanline_decode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_start_scanline_decode_0_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.options = SkiaSharp.SKCodecOptionsInternal.unmarshal(pData + 24); + } + return ret; + } + } + SkiaSharp.sk_codec_start_scanline_decode_0_Params = sk_codec_start_scanline_decode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_scanline_decode_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + this.options = new SkiaSharp.SKCodecOptionsInternal(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(40); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + this.options.marshal(pData + 20); + } + } + SkiaSharp.sk_codec_start_scanline_decode_0_Return = sk_codec_start_scanline_decode_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_scanline_decode_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_codec_start_scanline_decode_1_Params(); + { + ret.codec = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.optionsZero = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_codec_start_scanline_decode_1_Params = sk_codec_start_scanline_decode_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_codec_start_scanline_decode_1_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_codec_start_scanline_decode_1_Return = sk_codec_start_scanline_decode_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_get_bit_shift_0_Params { + /* Pack=4 */ + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_color_get_bit_shift_0_Params(); + return ret; + } + } + SkiaSharp.sk_color_get_bit_shift_0_Params = sk_color_get_bit_shift_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_get_bit_shift_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.a, "i32"); + memoryContext.setValue(pData + 4, this.r, "i32"); + memoryContext.setValue(pData + 8, this.g, "i32"); + memoryContext.setValue(pData + 12, this.b, "i32"); + } + } + SkiaSharp.sk_color_get_bit_shift_0_Return = sk_color_get_bit_shift_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_premultiply_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_color_premultiply_0_Params(); + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_color_premultiply_0_Params = sk_color_premultiply_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_premultiply_array_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_color_premultiply_array_0_Params(); + { + ret.colors_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.size = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.pmcolors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKPMColor 4 False*/ + if (pArray !== 0) { + ret.pmcolors = new Array(); + for (var i = 0; i < ret.pmcolors_Length; i++) { + ret.pmcolors.push(SkiaSharp.SKPMColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.pmcolors = null; + } + } + return ret; + } + } + SkiaSharp.sk_color_premultiply_array_0_Params = sk_color_premultiply_array_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_unpremultiply_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_color_unpremultiply_0_Params(); + { + ret.pmcolor = SkiaSharp.SKPMColor.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_color_unpremultiply_0_Params = sk_color_unpremultiply_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_color_unpremultiply_array_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_color_unpremultiply_array_0_Params(); + { + ret.pmcolors_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPMColor 4 False*/ + if (pArray !== 0) { + ret.pmcolors = new Array(); + for (var i = 0; i < ret.pmcolors_Length; i++) { + ret.pmcolors.push(SkiaSharp.SKPMColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.pmcolors = null; + } + } + { + ret.size = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + return ret; + } + } + SkiaSharp.sk_color_unpremultiply_array_0_Params = sk_color_unpremultiply_array_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_color_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_color_matrix_0_Params(); + { + ret.array_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.array = new Array(); + for (var i = 0; i < ret.array_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.array.push(Number(value)); + } + } + else { + ret.array = null; + } + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_color_matrix_0_Params = sk_colorfilter_new_color_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_compose_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_compose_0_Params(); + { + ret.outer = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.inner = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_compose_0_Params = sk_colorfilter_new_compose_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_high_contrast_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_high_contrast_0_Params(); + { + ret.config = SkiaSharp.SKHighContrastConfig.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_high_contrast_0_Params = sk_colorfilter_new_high_contrast_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_high_contrast_0_Return { + constructor() { + this.config = new SkiaSharp.SKHighContrastConfig(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.config.marshal(pData + 0); + } + } + SkiaSharp.sk_colorfilter_new_high_contrast_0_Return = sk_colorfilter_new_high_contrast_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_lighting_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_lighting_0_Params(); + { + ret.mul = SkiaSharp.SKColor.unmarshal(pData + 0); + } + { + ret.add = SkiaSharp.SKColor.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_lighting_0_Params = sk_colorfilter_new_lighting_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_mode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_mode_0_Params(); + { + ret.c = SkiaSharp.SKColor.unmarshal(pData + 0); + } + { + ret.mode = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_mode_0_Params = sk_colorfilter_new_mode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_table_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_table_0_Params(); + { + ret.table_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.table = new Array(); + for (var i = 0; i < ret.table_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.table.push(Number(value)); + } + } + else { + ret.table = null; + } + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_table_0_Params = sk_colorfilter_new_table_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_new_table_argb_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_new_table_argb_0_Params(); + { + ret.tableA_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.tableA = new Array(); + for (var i = 0; i < ret.tableA_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.tableA.push(Number(value)); + } + } + else { + ret.tableA = null; + } + } + { + ret.tableR_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.tableR = new Array(); + for (var i = 0; i < ret.tableR_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.tableR.push(Number(value)); + } + } + else { + ret.tableR = null; + } + } + { + ret.tableG_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.tableG = new Array(); + for (var i = 0; i < ret.tableG_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.tableG.push(Number(value)); + } + } + else { + ret.tableG = null; + } + } + { + ret.tableB_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.tableB = new Array(); + for (var i = 0; i < ret.tableB_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.tableB.push(Number(value)); + } + } + else { + ret.tableB = null; + } + } + return ret; + } + } + SkiaSharp.sk_colorfilter_new_table_argb_0_Params = sk_colorfilter_new_table_argb_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorfilter_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorfilter_unref_0_Params(); + { + ret.filter = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorfilter_unref_0_Params = sk_colorfilter_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_as_from_xyzd50_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_as_from_xyzd50_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_as_from_xyzd50_0_Params = sk_colorspace_as_from_xyzd50_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_as_to_xyzd50_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_as_to_xyzd50_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_as_to_xyzd50_0_Params = sk_colorspace_as_to_xyzd50_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_equals_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_equals_0_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_equals_0_Params = sk_colorspace_equals_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_gamma_close_to_srgb_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_gamma_close_to_srgb_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_gamma_close_to_srgb_0_Params = sk_colorspace_gamma_close_to_srgb_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_gamma_get_gamma_named_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_gamma_get_gamma_named_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_gamma_get_gamma_named_0_Params = sk_colorspace_gamma_get_gamma_named_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_gamma_get_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_gamma_get_type_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_gamma_get_type_0_Params = sk_colorspace_gamma_get_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_gamma_is_linear_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_gamma_is_linear_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_gamma_is_linear_0_Params = sk_colorspace_gamma_is_linear_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_is_numerical_transfer_fn_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_is_numerical_transfer_fn_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_is_numerical_transfer_fn_0_Params = sk_colorspace_is_numerical_transfer_fn_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_is_numerical_transfer_fn_0_Return { + constructor() { + this.fn = new SkiaSharp.SKColorSpaceTransferFn(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.fn.marshal(pData + 0); + } + } + SkiaSharp.sk_colorspace_is_numerical_transfer_fn_0_Return = sk_colorspace_is_numerical_transfer_fn_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_is_srgb_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_is_srgb_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_is_srgb_0_Params = sk_colorspace_is_srgb_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_icc_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_icc_0_Params(); + { + ret.input = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.len = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_icc_0_Params = sk_colorspace_new_icc_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_icc_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_icc_1_Params(); + { + ret.input_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.input = new Array(); + for (var i = 0; i < ret.input_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.input.push(Number(value)); + } + } + else { + ret.input = null; + } + } + { + ret.len = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_icc_1_Params = sk_colorspace_new_icc_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_coeffs_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_coeffs_0_Params(); + { + ret.coeffs = SkiaSharp.SKColorSpaceTransferFn.unmarshal(pData + 0); + } + { + ret.toXYZD50 = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_coeffs_0_Params = sk_colorspace_new_rgb_with_coeffs_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_coeffs_0_Return { + constructor() { + this.coeffs = new SkiaSharp.SKColorSpaceTransferFn(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.coeffs.marshal(pData + 0); + } + } + SkiaSharp.sk_colorspace_new_rgb_with_coeffs_0_Return = sk_colorspace_new_rgb_with_coeffs_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Params(); + { + ret.coeffs = SkiaSharp.SKColorSpaceTransferFn.unmarshal(pData + 0); + } + { + ret.gamut = Number(memoryContext.getValue(pData + 28, "i32")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Params = sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Return { + constructor() { + this.coeffs = new SkiaSharp.SKColorSpaceTransferFn(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.coeffs.marshal(pData + 0); + } + } + SkiaSharp.sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Return = sk_colorspace_new_rgb_with_coeffs_and_gamut_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_gamma_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_gamma_0_Params(); + { + ret.gamma = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.toXYZD50 = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_gamma_0_Params = sk_colorspace_new_rgb_with_gamma_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_gamma_and_gamut_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_gamma_and_gamut_0_Params(); + { + ret.gamma = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.gamut = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_gamma_and_gamut_0_Params = sk_colorspace_new_rgb_with_gamma_and_gamut_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_gamma_named_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_gamma_named_0_Params(); + { + ret.gamma = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.toXYZD50 = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_gamma_named_0_Params = sk_colorspace_new_rgb_with_gamma_named_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Params(); + { + ret.gamma = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.gamut = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Params = sk_colorspace_new_rgb_with_gamma_named_and_gamut_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_to_xyzd50_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_to_xyzd50_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.toXYZD50 = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_to_xyzd50_0_Params = sk_colorspace_to_xyzd50_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_transfer_fn_invert_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_transfer_fn_invert_0_Params(); + { + ret.transfer = SkiaSharp.SKColorSpaceTransferFn.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_colorspace_transfer_fn_invert_0_Params = sk_colorspace_transfer_fn_invert_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_transfer_fn_invert_0_Return { + constructor() { + this.transfer = new SkiaSharp.SKColorSpaceTransferFn(); + this.inverted = new SkiaSharp.SKColorSpaceTransferFn(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(56); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.transfer.marshal(pData + 0); + this.inverted.marshal(pData + 28); + } + } + SkiaSharp.sk_colorspace_transfer_fn_invert_0_Return = sk_colorspace_transfer_fn_invert_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_transfer_fn_transform_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_transfer_fn_transform_0_Params(); + { + ret.transfer = SkiaSharp.SKColorSpaceTransferFn.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "float")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_transfer_fn_transform_0_Params = sk_colorspace_transfer_fn_transform_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_transfer_fn_transform_0_Return { + constructor() { + this.transfer = new SkiaSharp.SKColorSpaceTransferFn(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.transfer.marshal(pData + 0); + } + } + SkiaSharp.sk_colorspace_transfer_fn_transform_0_Return = sk_colorspace_transfer_fn_transform_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspace_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspace_unref_0_Params(); + { + ret.cColorSpace = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspace_unref_0_Params = sk_colorspace_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspaceprimaries_to_xyzd50_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colorspaceprimaries_to_xyzd50_0_Params(); + { + ret.primaries = SkiaSharp.SKColorSpacePrimaries.unmarshal(pData + 0); + } + { + ret.toXYZD50 = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_colorspaceprimaries_to_xyzd50_0_Params = sk_colorspaceprimaries_to_xyzd50_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colorspaceprimaries_to_xyzd50_0_Return { + constructor() { + this.primaries = new SkiaSharp.SKColorSpacePrimaries(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.primaries.marshal(pData + 0); + } + } + SkiaSharp.sk_colorspaceprimaries_to_xyzd50_0_Return = sk_colorspaceprimaries_to_xyzd50_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colortable_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colortable_count_0_Params(); + { + ret.ctable = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colortable_count_0_Params = sk_colortable_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colortable_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colortable_new_0_Params(); + { + ret.colors_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPMColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKPMColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_colortable_new_0_Params = sk_colortable_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colortable_read_colors_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colortable_read_colors_0_Params(); + { + ret.ctable = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colortable_read_colors_0_Params = sk_colortable_read_colors_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colortable_read_colors_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.colors, "*"); + } + } + SkiaSharp.sk_colortable_read_colors_0_Return = sk_colortable_read_colors_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_colortable_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_colortable_unref_0_Params(); + { + ret.ctable = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_colortable_unref_0_Params = sk_colortable_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_get_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_get_data_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_get_data_0_Params = sk_data_get_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_get_size_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_get_size_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_get_size_0_Params = sk_data_get_size_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_from_file_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_from_file_0_Params(); + { + ret.utf8path_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.utf8path = new Array(); + for (var i = 0; i < ret.utf8path_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.utf8path.push(Number(value)); + } + } + else { + ret.utf8path = null; + } + } + return ret; + } + } + SkiaSharp.sk_data_new_from_file_0_Params = sk_data_new_from_file_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_from_stream_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_from_stream_0_Params = sk_data_new_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_subset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_subset_0_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.offset = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_subset_0_Params = sk_data_new_subset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_uninitialized_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_uninitialized_0_Params(); + { + ret.size = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_uninitialized_0_Params = sk_data_new_uninitialized_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_with_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_with_copy_0_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_with_copy_0_Params = sk_data_new_with_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_with_copy_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_with_copy_1_Params(); + { + ret.src_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.src = new Array(); + for (var i = 0; i < ret.src_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.src.push(Number(value)); + } + } + else { + ret.src = null; + } + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_with_copy_1_Params = sk_data_new_with_copy_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_new_with_proc_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_new_with_proc_0_Params(); + { + ret.ptr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.proc = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.ctx = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_new_with_proc_0_Params = sk_data_new_with_proc_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_data_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_data_unref_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_data_unref_0_Params = sk_data_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_abort_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_abort_0_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_abort_0_Params = sk_document_abort_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_begin_page_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_begin_page_0_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.width = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.height = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.content = SkiaSharp.SKRect.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.sk_document_begin_page_0_Params = sk_document_begin_page_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_begin_page_0_Return { + constructor() { + this.content = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.content.marshal(pData + 0); + } + } + SkiaSharp.sk_document_begin_page_0_Return = sk_document_begin_page_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_begin_page_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_begin_page_1_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.width = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.height = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.contentZero = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_begin_page_1_Params = sk_document_begin_page_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_close_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_close_0_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_close_0_Params = sk_document_close_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_create_pdf_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_create_pdf_from_stream_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_create_pdf_from_stream_0_Params = sk_document_create_pdf_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_create_pdf_from_stream_with_metadata_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_create_pdf_from_stream_with_metadata_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.metadata = SkiaSharp.SKDocumentPdfMetadataInternal.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_document_create_pdf_from_stream_with_metadata_0_Params = sk_document_create_pdf_from_stream_with_metadata_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_create_pdf_from_stream_with_metadata_0_Return { + constructor() { + this.metadata = new SkiaSharp.SKDocumentPdfMetadataInternal(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.metadata.marshal(pData + 0); + } + } + SkiaSharp.sk_document_create_pdf_from_stream_with_metadata_0_Return = sk_document_create_pdf_from_stream_with_metadata_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_create_xps_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_create_xps_from_stream_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dpi = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_document_create_xps_from_stream_0_Params = sk_document_create_xps_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_end_page_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_end_page_0_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_end_page_0_Params = sk_document_end_page_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_document_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_document_unref_0_Params(); + { + ret.document = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_document_unref_0_Params = sk_document_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_draw_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_drawable_draw_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.c = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_drawable_draw_0_Params = sk_drawable_draw_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_draw_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_drawable_draw_0_Return = sk_drawable_draw_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_get_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_drawable_get_bounds_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_drawable_get_bounds_0_Params = sk_drawable_get_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_get_bounds_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_drawable_get_bounds_0_Return = sk_drawable_get_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_get_generation_id_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_drawable_get_generation_id_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_drawable_get_generation_id_0_Params = sk_drawable_get_generation_id_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_new_picture_snapshot_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_drawable_new_picture_snapshot_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_drawable_new_picture_snapshot_0_Params = sk_drawable_new_picture_snapshot_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_drawable_notify_drawing_changed_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_drawable_notify_drawing_changed_0_Params(); + { + ret.d = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_drawable_notify_drawing_changed_0_Params = sk_drawable_notify_drawing_changed_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_dynamicmemorywstream_copy_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_dynamicmemorywstream_copy_to_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.data = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_dynamicmemorywstream_copy_to_0_Params = sk_dynamicmemorywstream_copy_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_dynamicmemorywstream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_dynamicmemorywstream_destroy_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_dynamicmemorywstream_destroy_0_Params = sk_dynamicmemorywstream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_dynamicmemorywstream_detach_as_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_dynamicmemorywstream_detach_as_data_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_dynamicmemorywstream_detach_as_data_0_Params = sk_dynamicmemorywstream_detach_as_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_dynamicmemorywstream_detach_as_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_dynamicmemorywstream_detach_as_stream_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_dynamicmemorywstream_detach_as_stream_0_Params = sk_dynamicmemorywstream_detach_as_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_dynamicmemorywstream_write_to_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_dynamicmemorywstream_write_to_stream_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_dynamicmemorywstream_write_to_stream_0_Params = sk_dynamicmemorywstream_write_to_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filestream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filestream_destroy_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_filestream_destroy_0_Params = sk_filestream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filestream_is_valid_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filestream_is_valid_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_filestream_is_valid_0_Params = sk_filestream_is_valid_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filestream_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filestream_new_0_Params(); + { + ret.utf8path_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.utf8path = new Array(); + for (var i = 0; i < ret.utf8path_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.utf8path.push(Number(value)); + } + } + else { + ret.utf8path = null; + } + } + return ret; + } + } + SkiaSharp.sk_filestream_new_0_Params = sk_filestream_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filewstream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filewstream_destroy_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_filewstream_destroy_0_Params = sk_filewstream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filewstream_is_valid_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filewstream_is_valid_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_filewstream_is_valid_0_Params = sk_filewstream_is_valid_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_filewstream_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_filewstream_new_0_Params(); + { + ret.utf8path_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.utf8path = new Array(); + for (var i = 0; i < ret.utf8path_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.utf8path.push(Number(value)); + } + } + else { + ret.utf8path = null; + } + } + return ret; + } + } + SkiaSharp.sk_filewstream_new_0_Params = sk_filewstream_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_count_families_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_count_families_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_count_families_0_Params = sk_fontmgr_count_families_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_create_from_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_create_from_data_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.data = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_create_from_data_0_Params = sk_fontmgr_create_from_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_create_from_file_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_create_from_file_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.utf8path_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.utf8path = new Array(); + for (var i = 0; i < ret.utf8path_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.utf8path.push(Number(value)); + } + } + else { + ret.utf8path = null; + } + } + { + ret.index = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_create_from_file_0_Params = sk_fontmgr_create_from_file_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_create_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_create_from_stream_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.stream = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_create_from_stream_0_Params = sk_fontmgr_create_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_create_styleset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_create_styleset_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_create_styleset_0_Params = sk_fontmgr_create_styleset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_get_family_name_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_get_family_name_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.familyName = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_get_family_name_0_Params = sk_fontmgr_get_family_name_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_match_face_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_match_face_style_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.face = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.style = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_match_face_style_0_Params = sk_fontmgr_match_face_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_match_family_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_match_family_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.familyName = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.familyName = null; + } + } + return ret; + } + } + SkiaSharp.sk_fontmgr_match_family_0_Params = sk_fontmgr_match_family_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_match_family_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_match_family_style_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.familyName = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.familyName = null; + } + } + { + ret.style = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_match_family_style_0_Params = sk_fontmgr_match_family_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_match_family_style_character_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_match_family_style_character_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.familyName = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.familyName = null; + } + } + { + ret.style = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.bcp47_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*string 4 True*/ + if (pArray !== 0) { + ret.bcp47 = new Array(); + for (var i = 0; i < ret.bcp47_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "*"); + if (value !== 0) { + ret.bcp47.push(String(MonoRuntime.conv_string(value))); + } + else { + ret.bcp47.push(null); + } + } + } + else { + ret.bcp47 = null; + } + } + { + ret.bcp47Count = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.character = Number(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_match_family_style_character_0_Params = sk_fontmgr_match_family_style_character_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontmgr_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontmgr_unref_0_Params(); + { + ret.fontmgr = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontmgr_unref_0_Params = sk_fontmgr_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyle_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyle_delete_0_Params(); + { + ret.fs = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyle_delete_0_Params = sk_fontstyle_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyle_get_slant_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyle_get_slant_0_Params(); + { + ret.fs = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyle_get_slant_0_Params = sk_fontstyle_get_slant_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyle_get_weight_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyle_get_weight_0_Params(); + { + ret.fs = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyle_get_weight_0_Params = sk_fontstyle_get_weight_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyle_get_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyle_get_width_0_Params(); + { + ret.fs = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyle_get_width_0_Params = sk_fontstyle_get_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyle_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyle_new_0_Params(); + { + ret.weight = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.width = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.slant = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontstyle_new_0_Params = sk_fontstyle_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyleset_create_typeface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyleset_create_typeface_0_Params(); + { + ret.fss = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_fontstyleset_create_typeface_0_Params = sk_fontstyleset_create_typeface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyleset_get_count_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyleset_get_count_0_Params(); + { + ret.fss = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyleset_get_count_0_Params = sk_fontstyleset_get_count_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyleset_get_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyleset_get_style_0_Params(); + { + ret.fss = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.fs = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.style = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyleset_get_style_0_Params = sk_fontstyleset_get_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyleset_match_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyleset_match_style_0_Params(); + { + ret.fss = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.style = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyleset_match_style_0_Params = sk_fontstyleset_match_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_fontstyleset_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_fontstyleset_unref_0_Params(); + { + ret.fss = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_fontstyleset_unref_0_Params = sk_fontstyleset_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_encode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_encode_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_encode_0_Params = sk_image_encode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_encode_specific_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_encode_specific_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.encoder = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.quality = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_image_encode_specific_0_Params = sk_image_encode_specific_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_alpha_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_alpha_type_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_alpha_type_0_Params = sk_image_get_alpha_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_color_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_color_type_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_color_type_0_Params = sk_image_get_color_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_colorspace_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_colorspace_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_colorspace_0_Params = sk_image_get_colorspace_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_height_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_height_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_height_0_Params = sk_image_get_height_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_unique_id_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_unique_id_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_unique_id_0_Params = sk_image_get_unique_id_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_get_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_get_width_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_get_width_0_Params = sk_image_get_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_is_alpha_only_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_is_alpha_only_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_is_alpha_only_0_Params = sk_image_is_alpha_only_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_is_lazy_generated_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_is_lazy_generated_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_is_lazy_generated_0_Params = sk_image_is_lazy_generated_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_is_texture_backed_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_is_texture_backed_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_is_texture_backed_0_Params = sk_image_is_texture_backed_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_non_texture_image_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_make_non_texture_image_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_make_non_texture_image_0_Params = sk_image_make_non_texture_image_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_shader_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_make_shader_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tileX = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.tileY = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.localMatrix = SkiaSharp.SKMatrix.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.sk_image_make_shader_0_Params = sk_image_make_shader_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_shader_0_Return { + constructor() { + this.localMatrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.localMatrix.marshal(pData + 0); + } + } + SkiaSharp.sk_image_make_shader_0_Return = sk_image_make_shader_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_shader_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_make_shader_1_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tileX = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.tileY = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.localMatrixZero = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_make_shader_1_Params = sk_image_make_shader_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_subset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_make_subset_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_image_make_subset_0_Params = sk_image_make_subset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_subset_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + } + } + SkiaSharp.sk_image_make_subset_0_Return = sk_image_make_subset_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_with_filter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_make_with_filter_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filter = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + { + ret.clipbounds = SkiaSharp.SKRectI.unmarshal(pData + 24); + } + return ret; + } + } + SkiaSharp.sk_image_make_with_filter_0_Params = sk_image_make_with_filter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_make_with_filter_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + this.clipbounds = new SkiaSharp.SKRectI(); + this.outSubset = new SkiaSharp.SKRectI(); + this.outOffset = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(56); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + this.clipbounds.marshal(pData + 16); + this.outSubset.marshal(pData + 32); + this.outOffset.marshal(pData + 48); + } + } + SkiaSharp.sk_image_make_with_filter_0_Return = sk_image_make_with_filter_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_adopted_texture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_adopted_texture_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.texture = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.alpha = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.colorSpace = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_adopted_texture_0_Params = sk_image_new_from_adopted_texture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_bitmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_bitmap_0_Params(); + { + ret.cbitmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_bitmap_0_Params = sk_image_new_from_bitmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_encoded_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_encoded_0_Params(); + { + ret.encoded = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_encoded_0_Params = sk_image_new_from_encoded_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_encoded_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + } + } + SkiaSharp.sk_image_new_from_encoded_0_Return = sk_image_new_from_encoded_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_encoded_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_encoded_1_Params(); + { + ret.encoded = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.subsetZero = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_encoded_1_Params = sk_image_new_from_encoded_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_picture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_picture_0_Params(); + { + ret.picture = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dimensions = SkiaSharp.SKSizeI.unmarshal(pData + 4); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 12); + } + { + ret.paint = Number(memoryContext.getValue(pData + 48, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_picture_0_Params = sk_image_new_from_picture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_picture_0_Return { + constructor() { + this.dimensions = new SkiaSharp.SKSizeI(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dimensions.marshal(pData + 0); + this.matrix.marshal(pData + 8); + } + } + SkiaSharp.sk_image_new_from_picture_0_Return = sk_image_new_from_picture_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_picture_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_picture_1_Params(); + { + ret.picture = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dimensions = SkiaSharp.SKSizeI.unmarshal(pData + 4); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_picture_1_Params = sk_image_new_from_picture_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_picture_1_Return { + constructor() { + this.dimensions = new SkiaSharp.SKSizeI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dimensions.marshal(pData + 0); + } + } + SkiaSharp.sk_image_new_from_picture_1_Return = sk_image_new_from_picture_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_from_texture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_from_texture_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.texture = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.alpha = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.colorSpace = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.releaseProc = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.releaseContext = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_from_texture_0_Params = sk_image_new_from_texture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_raster_0_Params(); + { + ret.pixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.releaseProc = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.context = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_raster_0_Params = sk_image_new_raster_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_raster_copy_0_Params(); + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 0); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_raster_copy_0_Params = sk_image_new_raster_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_copy_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_image_new_raster_copy_0_Return = sk_image_new_raster_copy_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_copy_with_pixmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_raster_copy_with_pixmap_0_Params(); + { + ret.pixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_raster_copy_with_pixmap_0_Params = sk_image_new_raster_copy_with_pixmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_new_raster_data_0_Params(); + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 0); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_new_raster_data_0_Params = sk_image_new_raster_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_new_raster_data_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_image_new_raster_data_0_Return = sk_image_new_raster_data_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_peek_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_peek_pixels_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pixmap = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_peek_pixels_0_Params = sk_image_peek_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_read_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_read_pixels_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.dstPixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.dstRowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.srcX = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.srcY = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.cachingHint = Number(memoryContext.getValue(pData + 40, "i32")); + } + return ret; + } + } + SkiaSharp.sk_image_read_pixels_0_Params = sk_image_read_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_read_pixels_0_Return { + constructor() { + this.dstInfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dstInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_image_read_pixels_0_Return = sk_image_read_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_read_pixels_into_pixmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_read_pixels_into_pixmap_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.srcX = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.srcY = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.cachingHint = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_image_read_pixels_into_pixmap_0_Params = sk_image_read_pixels_into_pixmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_ref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_ref_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_ref_0_Params = sk_image_ref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_ref_encoded_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_ref_encoded_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_ref_encoded_0_Params = sk_image_ref_encoded_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_scale_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_scale_pixels_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.quality = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.cachingHint = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_image_scale_pixels_0_Params = sk_image_scale_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_image_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_image_unref_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_image_unref_0_Params = sk_image_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_destructor_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_croprect_destructor_0_Params(); + { + ret.cropRect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_croprect_destructor_0_Params = sk_imagefilter_croprect_destructor_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_get_flags_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_croprect_get_flags_0_Params(); + { + ret.cropRect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_croprect_get_flags_0_Params = sk_imagefilter_croprect_get_flags_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_get_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_croprect_get_rect_0_Params(); + { + ret.cropRect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_croprect_get_rect_0_Params = sk_imagefilter_croprect_get_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_get_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_croprect_get_rect_0_Return = sk_imagefilter_croprect_get_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_new_with_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_croprect_new_with_rect_0_Params(); + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 0); + } + { + ret.flags = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_croprect_new_with_rect_0_Params = sk_imagefilter_croprect_new_with_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_croprect_new_with_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_croprect_new_with_rect_0_Return = sk_imagefilter_croprect_new_with_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_alpha_threshold_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_alpha_threshold_0_Params(); + { + ret.region = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.innerThreshold = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.outerThreshold = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_alpha_threshold_0_Params = sk_imagefilter_new_alpha_threshold_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_arithmetic_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_arithmetic_0_Params(); + { + ret.k1 = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.k2 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.k3 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.k4 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.enforcePMColor = Boolean(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.background = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.foreground = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_arithmetic_0_Params = sk_imagefilter_new_arithmetic_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_blur_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_blur_0_Params(); + { + ret.sigmaX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.sigmaY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_blur_0_Params = sk_imagefilter_new_blur_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_color_filter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_color_filter_0_Params(); + { + ret.cf = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.input = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_color_filter_0_Params = sk_imagefilter_new_color_filter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_compose_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_compose_0_Params(); + { + ret.outer = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.inner = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_compose_0_Params = sk_imagefilter_new_compose_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_dilate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_dilate_0_Params(); + { + ret.radiusX = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.radiusY = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.input = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_dilate_0_Params = sk_imagefilter_new_dilate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_displacement_map_effect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_displacement_map_effect_0_Params(); + { + ret.xChannelSelector = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.yChannelSelector = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.scale = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.displacement = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.color = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_displacement_map_effect_0_Params = sk_imagefilter_new_displacement_map_effect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_distant_lit_diffuse_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_distant_lit_diffuse_0_Params(); + { + ret.direction = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 12); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.kd = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_distant_lit_diffuse_0_Params = sk_imagefilter_new_distant_lit_diffuse_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_distant_lit_diffuse_0_Return { + constructor() { + this.direction = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.direction.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_distant_lit_diffuse_0_Return = sk_imagefilter_new_distant_lit_diffuse_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_distant_lit_specular_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_distant_lit_specular_0_Params(); + { + ret.direction = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 12); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.ks = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.shininess = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_distant_lit_specular_0_Params = sk_imagefilter_new_distant_lit_specular_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_distant_lit_specular_0_Return { + constructor() { + this.direction = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.direction.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_distant_lit_specular_0_Return = sk_imagefilter_new_distant_lit_specular_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_drop_shadow_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_drop_shadow_0_Params(); + { + ret.dx = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sigmaX = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.sigmaY = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 16); + } + { + ret.shadowMode = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.input = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_drop_shadow_0_Params = sk_imagefilter_new_drop_shadow_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_erode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_erode_0_Params(); + { + ret.radiusX = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.radiusY = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.input = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_erode_0_Params = sk_imagefilter_new_erode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_image_source_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_image_source_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.srcRect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.dstRect = SkiaSharp.SKRect.unmarshal(pData + 20); + } + { + ret.filterQuality = Number(memoryContext.getValue(pData + 36, "i32")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_image_source_0_Params = sk_imagefilter_new_image_source_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_image_source_0_Return { + constructor() { + this.srcRect = new SkiaSharp.SKRect(); + this.dstRect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.srcRect.marshal(pData + 0); + this.dstRect.marshal(pData + 16); + } + } + SkiaSharp.sk_imagefilter_new_image_source_0_Return = sk_imagefilter_new_image_source_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_image_source_default_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_image_source_default_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_image_source_default_0_Params = sk_imagefilter_new_image_source_default_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_magnifier_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_magnifier_0_Params(); + { + ret.src = SkiaSharp.SKRect.unmarshal(pData + 0); + } + { + ret.inset = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_magnifier_0_Params = sk_imagefilter_new_magnifier_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_magnifier_0_Return { + constructor() { + this.src = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.src.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_magnifier_0_Return = sk_imagefilter_new_magnifier_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_matrix_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.quality = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.input = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_matrix_0_Params = sk_imagefilter_new_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_matrix_0_Return = sk_imagefilter_new_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_matrix_convolution_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_matrix_convolution_0_Params(); + { + ret.kernelSize = SkiaSharp.SKSizeI.unmarshal(pData + 0); + } + { + ret.kernel_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.kernel = new Array(); + for (var i = 0; i < ret.kernel_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.kernel.push(Number(value)); + } + } + else { + ret.kernel = null; + } + } + { + ret.gain = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.bias = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.kernelOffset = SkiaSharp.SKPointI.unmarshal(pData + 24); + } + { + ret.tileMode = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.convolveAlpha = Boolean(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.input = Number(memoryContext.getValue(pData + 40, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 44, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_matrix_convolution_0_Params = sk_imagefilter_new_matrix_convolution_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_matrix_convolution_0_Return { + constructor() { + this.kernelSize = new SkiaSharp.SKSizeI(); + this.kernelOffset = new SkiaSharp.SKPointI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.kernelSize.marshal(pData + 0); + this.kernelOffset.marshal(pData + 8); + } + } + SkiaSharp.sk_imagefilter_new_matrix_convolution_0_Return = sk_imagefilter_new_matrix_convolution_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_merge_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_merge_0_Params(); + { + ret.filters_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*System.IntPtr 4 False*/ + if (pArray !== 0) { + ret.filters = new Array(); + for (var i = 0; i < ret.filters_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "*"); + ret.filters.push(Number(value)); + } + } + else { + ret.filters = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_merge_0_Params = sk_imagefilter_new_merge_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_offset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_offset_0_Params(); + { + ret.dx = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_offset_0_Params = sk_imagefilter_new_offset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_paint_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_paint_0_Params(); + { + ret.paint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_paint_0_Params = sk_imagefilter_new_paint_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_picture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_picture_0_Params(); + { + ret.picture = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_picture_0_Params = sk_imagefilter_new_picture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_picture_with_croprect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_picture_with_croprect_0_Params(); + { + ret.picture = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cropRect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_picture_with_croprect_0_Params = sk_imagefilter_new_picture_with_croprect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_picture_with_croprect_0_Return { + constructor() { + this.cropRect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cropRect.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_picture_with_croprect_0_Return = sk_imagefilter_new_picture_with_croprect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_point_lit_diffuse_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_point_lit_diffuse_0_Params(); + { + ret.location = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 12); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.kd = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_point_lit_diffuse_0_Params = sk_imagefilter_new_point_lit_diffuse_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_point_lit_diffuse_0_Return { + constructor() { + this.location = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.location.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_point_lit_diffuse_0_Return = sk_imagefilter_new_point_lit_diffuse_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_point_lit_specular_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_point_lit_specular_0_Params(); + { + ret.location = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 12); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.ks = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.shininess = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_point_lit_specular_0_Params = sk_imagefilter_new_point_lit_specular_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_point_lit_specular_0_Return { + constructor() { + this.location = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(12); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.location.marshal(pData + 0); + } + } + SkiaSharp.sk_imagefilter_new_point_lit_specular_0_Return = sk_imagefilter_new_point_lit_specular_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_spot_lit_diffuse_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_spot_lit_diffuse_0_Params(); + { + ret.location = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.target = SkiaSharp.SKPoint3.unmarshal(pData + 12); + } + { + ret.specularExponent = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.cutoffAngle = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 32); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.kd = Number(memoryContext.getValue(pData + 40, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 44, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 48, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_spot_lit_diffuse_0_Params = sk_imagefilter_new_spot_lit_diffuse_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_spot_lit_diffuse_0_Return { + constructor() { + this.location = new SkiaSharp.SKPoint3(); + this.target = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(24); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.location.marshal(pData + 0); + this.target.marshal(pData + 12); + } + } + SkiaSharp.sk_imagefilter_new_spot_lit_diffuse_0_Return = sk_imagefilter_new_spot_lit_diffuse_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_spot_lit_specular_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_spot_lit_specular_0_Params(); + { + ret.location = SkiaSharp.SKPoint3.unmarshal(pData + 0); + } + { + ret.target = SkiaSharp.SKPoint3.unmarshal(pData + 12); + } + { + ret.specularExponent = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.cutoffAngle = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.lightColor = SkiaSharp.SKColor.unmarshal(pData + 32); + } + { + ret.surfaceScale = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.ks = Number(memoryContext.getValue(pData + 40, "float")); + } + { + ret.shininess = Number(memoryContext.getValue(pData + 44, "float")); + } + { + ret.input = Number(memoryContext.getValue(pData + 48, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 52, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_spot_lit_specular_0_Params = sk_imagefilter_new_spot_lit_specular_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_spot_lit_specular_0_Return { + constructor() { + this.location = new SkiaSharp.SKPoint3(); + this.target = new SkiaSharp.SKPoint3(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(24); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.location.marshal(pData + 0); + this.target.marshal(pData + 12); + } + } + SkiaSharp.sk_imagefilter_new_spot_lit_specular_0_Return = sk_imagefilter_new_spot_lit_specular_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_tile_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_tile_0_Params(); + { + ret.src = SkiaSharp.SKRect.unmarshal(pData + 0); + } + { + ret.dst = SkiaSharp.SKRect.unmarshal(pData + 16); + } + { + ret.input = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_tile_0_Params = sk_imagefilter_new_tile_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_tile_0_Return { + constructor() { + this.src = new SkiaSharp.SKRect(); + this.dst = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(32); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.src.marshal(pData + 0); + this.dst.marshal(pData + 16); + } + } + SkiaSharp.sk_imagefilter_new_tile_0_Return = sk_imagefilter_new_tile_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_new_xfermode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_new_xfermode_0_Params(); + { + ret.mode = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.background = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.foreground = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cropRect = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_new_xfermode_0_Params = sk_imagefilter_new_xfermode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_imagefilter_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_imagefilter_unref_0_Params(); + { + ret.filter = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_imagefilter_unref_0_Params = sk_imagefilter_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_jpegencoder_encode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_jpegencoder_encode_0_Params(); + { + ret.dst = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.options = SkiaSharp.SKJpegEncoderOptions.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_jpegencoder_encode_0_Params = sk_jpegencoder_encode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_manageddrawable_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_manageddrawable_destroy_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_manageddrawable_destroy_0_Params = sk_manageddrawable_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_manageddrawable_set_delegates_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_manageddrawable_set_delegates_0_Params(); + { + ret.pDraw = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pGetBounds = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.pNewPictureSnapshot = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_manageddrawable_set_delegates_0_Params = sk_manageddrawable_set_delegates_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_managedstream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_managedstream_destroy_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_managedstream_destroy_0_Params = sk_managedstream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_managedstream_set_delegates_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_managedstream_set_delegates_0_Params(); + { + ret.pRead = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pPeek = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.pIsAtEnd = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.pHasPosition = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.pHasLength = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.pRewind = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.pGetPosition = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.pSeek = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.pMove = Number(memoryContext.getValue(pData + 32, "*")); + } + { + ret.pGetLength = Number(memoryContext.getValue(pData + 36, "*")); + } + { + ret.pCreateNew = Number(memoryContext.getValue(pData + 40, "*")); + } + { + ret.pDestroy = Number(memoryContext.getValue(pData + 44, "*")); + } + return ret; + } + } + SkiaSharp.sk_managedstream_set_delegates_0_Params = sk_managedstream_set_delegates_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_managedwstream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_managedwstream_destroy_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_managedwstream_destroy_0_Params = sk_managedwstream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_managedwstream_set_delegates_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_managedwstream_set_delegates_0_Params(); + { + ret.pWrite = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pFlush = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.pBytesWritten = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.pDestroy = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_managedwstream_set_delegates_0_Params = sk_managedwstream_set_delegates_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_alloc_image_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_alloc_image_0_Params(); + { + ret.bytes = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_mask_alloc_image_0_Params = sk_mask_alloc_image_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_compute_image_size_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_compute_image_size_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_mask_compute_image_size_0_Params = sk_mask_compute_image_size_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_compute_image_size_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_compute_image_size_0_Return = sk_mask_compute_image_size_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_compute_total_image_size_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_compute_total_image_size_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_mask_compute_total_image_size_0_Params = sk_mask_compute_total_image_size_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_compute_total_image_size_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_compute_total_image_size_0_Return = sk_mask_compute_total_image_size_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_free_image_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_free_image_0_Params(); + { + ret.image = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_mask_free_image_0_Params = sk_mask_free_image_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_get_addr_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 32, "i32")); + } + return ret; + } + } + SkiaSharp.sk_mask_get_addr_0_Params = sk_mask_get_addr_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_get_addr_0_Return = sk_mask_get_addr_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_1_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_get_addr_1_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 32, "i32")); + } + return ret; + } + } + SkiaSharp.sk_mask_get_addr_1_0_Params = sk_mask_get_addr_1_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_1_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_get_addr_1_0_Return = sk_mask_get_addr_1_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_32_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_get_addr_32_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 32, "i32")); + } + return ret; + } + } + SkiaSharp.sk_mask_get_addr_32_0_Params = sk_mask_get_addr_32_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_32_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_get_addr_32_0_Return = sk_mask_get_addr_32_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_8_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_get_addr_8_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 32, "i32")); + } + return ret; + } + } + SkiaSharp.sk_mask_get_addr_8_0_Params = sk_mask_get_addr_8_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_8_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_get_addr_8_0_Return = sk_mask_get_addr_8_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_lcd_16_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_get_addr_lcd_16_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 32, "i32")); + } + return ret; + } + } + SkiaSharp.sk_mask_get_addr_lcd_16_0_Params = sk_mask_get_addr_lcd_16_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_get_addr_lcd_16_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_get_addr_lcd_16_0_Return = sk_mask_get_addr_lcd_16_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_is_empty_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_mask_is_empty_0_Params(); + { + ret.cmask = SkiaSharp.SKMask.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_mask_is_empty_0_Params = sk_mask_is_empty_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_mask_is_empty_0_Return { + constructor() { + this.cmask = new SkiaSharp.SKMask(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(28); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cmask.marshal(pData + 0); + } + } + SkiaSharp.sk_mask_is_empty_0_Return = sk_mask_is_empty_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_blur_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_new_blur_0_Params(); + { + ret.style = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.sigma = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_maskfilter_new_blur_0_Params = sk_maskfilter_new_blur_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_blur_with_flags_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_new_blur_with_flags_0_Params(); + { + ret.style = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.sigma = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.occluder = SkiaSharp.SKRect.unmarshal(pData + 8); + } + { + ret.respectCTM = Boolean(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + } + SkiaSharp.sk_maskfilter_new_blur_with_flags_0_Params = sk_maskfilter_new_blur_with_flags_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_blur_with_flags_0_Return { + constructor() { + this.occluder = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.occluder.marshal(pData + 0); + } + } + SkiaSharp.sk_maskfilter_new_blur_with_flags_0_Return = sk_maskfilter_new_blur_with_flags_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_clip_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_new_clip_0_Params(); + { + ret.min = Number(memoryContext.getValue(pData + 0, "i8")); + } + { + ret.max = Number(memoryContext.getValue(pData + 4, "i8")); + } + return ret; + } + } + SkiaSharp.sk_maskfilter_new_clip_0_Params = sk_maskfilter_new_clip_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_gamma_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_new_gamma_0_Params(); + { + ret.gamma = Number(memoryContext.getValue(pData + 0, "float")); + } + return ret; + } + } + SkiaSharp.sk_maskfilter_new_gamma_0_Params = sk_maskfilter_new_gamma_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_new_table_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_new_table_0_Params(); + { + ret.table_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.table = new Array(); + for (var i = 0; i < ret.table_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.table.push(Number(value)); + } + } + else { + ret.table = null; + } + } + return ret; + } + } + SkiaSharp.sk_maskfilter_new_table_0_Params = sk_maskfilter_new_table_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_maskfilter_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_maskfilter_unref_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_maskfilter_unref_0_Params = sk_maskfilter_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_as_col_major_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_as_col_major_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.dst = new Array(); + for (var i = 0; i < ret.dst_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.dst.push(Number(value)); + } + } + else { + ret.dst = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_as_col_major_0_Params = sk_matrix44_as_col_major_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_as_row_major_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_as_row_major_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.dst = new Array(); + for (var i = 0; i < ret.dst_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.dst.push(Number(value)); + } + } + else { + ret.dst = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_as_row_major_0_Params = sk_matrix44_as_row_major_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_destroy_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_destroy_0_Params = sk_matrix44_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_determinant_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_determinant_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_determinant_0_Params = sk_matrix44_determinant_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_equals_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_equals_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.other = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_equals_0_Params = sk_matrix44_equals_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_get_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_get_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.row = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.col = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_get_0_Params = sk_matrix44_get_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_get_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_get_type_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_get_type_0_Params = sk_matrix44_get_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_invert_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_invert_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.inverse = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_invert_0_Params = sk_matrix44_invert_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_map2_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_map2_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src2_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.src2 = new Array(); + for (var i = 0; i < ret.src2_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.src2.push(Number(value)); + } + } + else { + ret.src2 = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.dst_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.dst = new Array(); + for (var i = 0; i < ret.dst_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.dst.push(Number(value)); + } + } + else { + ret.dst = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_map2_0_Params = sk_matrix44_map2_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_map_scalars_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_map_scalars_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.src = new Array(); + for (var i = 0; i < ret.src_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.src.push(Number(value)); + } + } + else { + ret.src = null; + } + } + { + ret.dst_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.dst = new Array(); + for (var i = 0; i < ret.dst_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.dst.push(Number(value)); + } + } + else { + ret.dst = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_map_scalars_0_Params = sk_matrix44_map_scalars_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_new_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_new_concat_0_Params(); + { + ret.a = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.b = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_new_concat_0_Params = sk_matrix44_new_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_new_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_new_copy_0_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_new_copy_0_Params = sk_matrix44_new_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_new_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_new_matrix_0_Params(); + { + ret.src = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_matrix44_new_matrix_0_Params = sk_matrix44_new_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_new_matrix_0_Return { + constructor() { + this.src = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.src.marshal(pData + 0); + } + } + SkiaSharp.sk_matrix44_new_matrix_0_Return = sk_matrix44_new_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_post_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_post_concat_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.m = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_post_concat_0_Params = sk_matrix44_post_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_post_scale_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_post_scale_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.sx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.sz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_post_scale_0_Params = sk_matrix44_post_scale_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_post_translate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_post_translate_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_post_translate_0_Params = sk_matrix44_post_translate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_pre_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_pre_concat_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.m = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_pre_concat_0_Params = sk_matrix44_pre_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_pre_scale_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_pre_scale_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.sx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.sz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_pre_scale_0_Params = sk_matrix44_pre_scale_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_pre_translate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_pre_translate_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_pre_translate_0_Params = sk_matrix44_pre_translate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_preserves_2d_axis_alignment_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_preserves_2d_axis_alignment_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.epsilon = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_preserves_2d_axis_alignment_0_Params = sk_matrix44_preserves_2d_axis_alignment_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.row = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.col = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.value = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_0_Params = sk_matrix44_set_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_col_major_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_col_major_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.src = new Array(); + for (var i = 0; i < ret.src_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.src.push(Number(value)); + } + } + else { + ret.src = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_col_major_0_Params = sk_matrix44_set_col_major_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_concat_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.a = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.b = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_concat_0_Params = sk_matrix44_set_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_identity_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_identity_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_identity_0_Params = sk_matrix44_set_identity_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_rotate_about_degrees_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_rotate_about_degrees_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.z = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.degrees = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_rotate_about_degrees_0_Params = sk_matrix44_set_rotate_about_degrees_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_rotate_about_radians_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_rotate_about_radians_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.z = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_rotate_about_radians_0_Params = sk_matrix44_set_rotate_about_radians_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_rotate_about_radians_unit_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_rotate_about_radians_unit_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.z = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.radians = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_rotate_about_radians_unit_0_Params = sk_matrix44_set_rotate_about_radians_unit_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_row_major_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_row_major_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.src = new Array(); + for (var i = 0; i < ret.src_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.src.push(Number(value)); + } + } + else { + ret.src = null; + } + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_row_major_0_Params = sk_matrix44_set_row_major_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_scale_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_scale_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.sx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.sy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.sz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_scale_0_Params = sk_matrix44_set_scale_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_set_translate_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_set_translate_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dz = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_set_translate_0_Params = sk_matrix44_set_translate_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_to_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_to_matrix_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_to_matrix_0_Params = sk_matrix44_to_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_to_matrix_0_Return { + constructor() { + this.dst = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dst.marshal(pData + 0); + } + } + SkiaSharp.sk_matrix44_to_matrix_0_Return = sk_matrix44_to_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix44_transpose_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix44_transpose_0_Params(); + { + ret.matrix = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_matrix44_transpose_0_Params = sk_matrix44_transpose_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_concat_0_Params(); + { + ret.target = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.first = SkiaSharp.SKMatrix.unmarshal(pData + 36); + } + { + ret.second = SkiaSharp.SKMatrix.unmarshal(pData + 72); + } + return ret; + } + } + SkiaSharp.sk_matrix_concat_0_Params = sk_matrix_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_concat_0_Return { + constructor() { + this.target = new SkiaSharp.SKMatrix(); + this.first = new SkiaSharp.SKMatrix(); + this.second = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(108); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.target.marshal(pData + 0); + this.first.marshal(pData + 36); + this.second.marshal(pData + 72); + } + } + SkiaSharp.sk_matrix_concat_0_Return = sk_matrix_concat_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_points_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.dst = Number(memoryContext.getValue(pData + 36, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 40, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 44, "i32")); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_points_0_Params = sk_matrix_map_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_points_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_matrix_map_points_0_Return = sk_matrix_map_points_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_radius_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_radius_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.radius = Number(memoryContext.getValue(pData + 36, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_radius_0_Params = sk_matrix_map_radius_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_radius_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_matrix_map_radius_0_Return = sk_matrix_map_radius_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_rect_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.source = SkiaSharp.SKRect.unmarshal(pData + 36); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_rect_0_Params = sk_matrix_map_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_rect_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + this.dest = new SkiaSharp.SKRect(); + this.source = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(68); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + this.dest.marshal(pData + 36); + this.source.marshal(pData + 52); + } + } + SkiaSharp.sk_matrix_map_rect_0_Return = sk_matrix_map_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_vector_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_vector_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 40, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_vector_0_Params = sk_matrix_map_vector_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_vector_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + this.result = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + this.result.marshal(pData + 36); + } + } + SkiaSharp.sk_matrix_map_vector_0_Return = sk_matrix_map_vector_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_vectors_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_vectors_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.dst = Number(memoryContext.getValue(pData + 36, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 40, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 44, "i32")); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_vectors_0_Params = sk_matrix_map_vectors_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_vectors_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_matrix_map_vectors_0_Return = sk_matrix_map_vectors_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_xy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_map_xy_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.x = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 40, "float")); + } + return ret; + } + } + SkiaSharp.sk_matrix_map_xy_0_Params = sk_matrix_map_xy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_map_xy_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + this.result = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + this.result.marshal(pData + 36); + } + } + SkiaSharp.sk_matrix_map_xy_0_Return = sk_matrix_map_xy_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_post_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_post_concat_0_Params(); + { + ret.target = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 36); + } + return ret; + } + } + SkiaSharp.sk_matrix_post_concat_0_Params = sk_matrix_post_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_post_concat_0_Return { + constructor() { + this.target = new SkiaSharp.SKMatrix(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(72); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.target.marshal(pData + 0); + this.matrix.marshal(pData + 36); + } + } + SkiaSharp.sk_matrix_post_concat_0_Return = sk_matrix_post_concat_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_pre_concat_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_pre_concat_0_Params(); + { + ret.target = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 36); + } + return ret; + } + } + SkiaSharp.sk_matrix_pre_concat_0_Params = sk_matrix_pre_concat_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_pre_concat_0_Return { + constructor() { + this.target = new SkiaSharp.SKMatrix(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(72); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.target.marshal(pData + 0); + this.matrix.marshal(pData + 36); + } + } + SkiaSharp.sk_matrix_pre_concat_0_Return = sk_matrix_pre_concat_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_try_invert_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_matrix_try_invert_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_matrix_try_invert_0_Params = sk_matrix_try_invert_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_matrix_try_invert_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + this.result = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(72); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + this.result.marshal(pData + 36); + } + } + SkiaSharp.sk_matrix_try_invert_0_Return = sk_matrix_try_invert_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_destroy_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_destroy_0_Params = sk_memorystream_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_new_with_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_new_with_data_0_Params(); + { + ret.data = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.copyData = Boolean(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_new_with_data_0_Params = sk_memorystream_new_with_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_new_with_data_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_new_with_data_1_Params(); + { + ret.data_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.data = new Array(); + for (var i = 0; i < ret.data_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.data.push(Number(value)); + } + } + else { + ret.data = null; + } + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.copyData = Boolean(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_new_with_data_1_Params = sk_memorystream_new_with_data_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_new_with_length_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_new_with_length_0_Params(); + { + ret.length = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_new_with_length_0_Params = sk_memorystream_new_with_length_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_new_with_skdata_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_new_with_skdata_0_Params(); + { + ret.data = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_new_with_skdata_0_Params = sk_memorystream_new_with_skdata_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_set_memory_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_set_memory_0_Params(); + { + ret.s = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.data = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.copyData = Boolean(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_set_memory_0_Params = sk_memorystream_set_memory_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_memorystream_set_memory_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_memorystream_set_memory_1_Params(); + { + ret.s = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.data_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.data = new Array(); + for (var i = 0; i < ret.data_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.data.push(Number(value)); + } + } + else { + ret.data = null; + } + } + { + ret.length = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.copyData = Boolean(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_memorystream_set_memory_1_Params = sk_memorystream_set_memory_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nodraw_canvas_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nodraw_canvas_destroy_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_nodraw_canvas_destroy_0_Params = sk_nodraw_canvas_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nodraw_canvas_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nodraw_canvas_new_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_nodraw_canvas_new_0_Params = sk_nodraw_canvas_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nway_canvas_add_canvas_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nway_canvas_add_canvas_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.canvas = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_nway_canvas_add_canvas_0_Params = sk_nway_canvas_add_canvas_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nway_canvas_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nway_canvas_destroy_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_nway_canvas_destroy_0_Params = sk_nway_canvas_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nway_canvas_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nway_canvas_new_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_nway_canvas_new_0_Params = sk_nway_canvas_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nway_canvas_remove_all_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nway_canvas_remove_all_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_nway_canvas_remove_all_0_Params = sk_nway_canvas_remove_all_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_nway_canvas_remove_canvas_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_nway_canvas_remove_canvas_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.canvas = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_nway_canvas_remove_canvas_0_Params = sk_nway_canvas_remove_canvas_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_opbuilder_add_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_opbuilder_add_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.path = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_opbuilder_add_0_Params = sk_opbuilder_add_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_opbuilder_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_opbuilder_destroy_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_opbuilder_destroy_0_Params = sk_opbuilder_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_opbuilder_resolve_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_opbuilder_resolve_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.result = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_opbuilder_resolve_0_Params = sk_opbuilder_resolve_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_overdraw_canvas_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_overdraw_canvas_destroy_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_overdraw_canvas_destroy_0_Params = sk_overdraw_canvas_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_overdraw_canvas_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_overdraw_canvas_new_0_Params(); + { + ret.canvas = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_overdraw_canvas_new_0_Params = sk_overdraw_canvas_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_break_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_break_text_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.maxWidth = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_break_text_0_Params = sk_paint_break_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_break_text_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.measuredWidth, "float"); + } + } + SkiaSharp.sk_paint_break_text_0_Return = sk_paint_break_text_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_clone_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_clone_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_clone_0_Params = sk_paint_clone_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_contains_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_contains_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_contains_text_0_Params = sk_paint_contains_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_count_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_count_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_count_text_0_Params = sk_paint_count_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_delete_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_delete_0_Params = sk_paint_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_blendmode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_blendmode_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_blendmode_0_Params = sk_paint_get_blendmode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_color_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_color_0_Params = sk_paint_get_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_colorfilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_colorfilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_colorfilter_0_Params = sk_paint_get_colorfilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fill_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_fill_path_0_Params(); + { + ret.paint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cullRect = SkiaSharp.SKRect.unmarshal(pData + 12); + } + { + ret.resScale = Number(memoryContext.getValue(pData + 28, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_fill_path_0_Params = sk_paint_get_fill_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fill_path_0_Return { + constructor() { + this.cullRect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cullRect.marshal(pData + 0); + } + } + SkiaSharp.sk_paint_get_fill_path_0_Return = sk_paint_get_fill_path_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fill_path_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_fill_path_1_Params(); + { + ret.paint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.cullRectZero = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.resScale = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_fill_path_1_Params = sk_paint_get_fill_path_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_filter_quality_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_filter_quality_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_filter_quality_0_Params = sk_paint_get_filter_quality_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fontmetrics_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_fontmetrics_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.scale = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_fontmetrics_0_Params = sk_paint_get_fontmetrics_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fontmetrics_0_Return { + constructor() { + this.fontMetrics = new SkiaSharp.SKFontMetrics(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(64); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.fontMetrics.marshal(pData + 0); + } + } + SkiaSharp.sk_paint_get_fontmetrics_0_Return = sk_paint_get_fontmetrics_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_fontmetrics_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_fontmetrics_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.fontMetricsZero = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.scale = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_fontmetrics_1_Params = sk_paint_get_fontmetrics_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_hinting_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_hinting_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_hinting_0_Params = sk_paint_get_hinting_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_imagefilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_imagefilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_imagefilter_0_Params = sk_paint_get_imagefilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_maskfilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_maskfilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_maskfilter_0_Params = sk_paint_get_maskfilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_path_effect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_path_effect_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_path_effect_0_Params = sk_paint_get_path_effect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_pos_text_blob_intercepts_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_pos_text_blob_intercepts_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.blob = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.bounds_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.bounds = new Array(); + for (var i = 0; i < ret.bounds_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.bounds.push(Number(value)); + } + } + else { + ret.bounds = null; + } + } + { + ret.intervals = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_pos_text_blob_intercepts_0_Params = sk_paint_get_pos_text_blob_intercepts_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_pos_text_h_intercepts_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_pos_text_h_intercepts_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.xpos_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.xpos = new Array(); + for (var i = 0; i < ret.xpos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.xpos.push(Number(value)); + } + } + else { + ret.xpos = null; + } + } + { + ret.y = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.bounds_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.bounds = new Array(); + for (var i = 0; i < ret.bounds_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.bounds.push(Number(value)); + } + } + else { + ret.bounds = null; + } + } + { + ret.intervals = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_pos_text_h_intercepts_0_Params = sk_paint_get_pos_text_h_intercepts_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_pos_text_intercepts_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_pos_text_intercepts_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.pos_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.pos = new Array(); + for (var i = 0; i < ret.pos_Length; i++) { + ret.pos.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.pos = null; + } + } + { + ret.bounds_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.bounds = new Array(); + for (var i = 0; i < ret.bounds_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.bounds.push(Number(value)); + } + } + else { + ret.bounds = null; + } + } + { + ret.intervals = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_pos_text_intercepts_0_Params = sk_paint_get_pos_text_intercepts_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_pos_text_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_pos_text_path_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + return ret; + } + } + SkiaSharp.sk_paint_get_pos_text_path_0_Params = sk_paint_get_pos_text_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_shader_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_shader_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_shader_0_Params = sk_paint_get_shader_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_stroke_cap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_stroke_cap_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_stroke_cap_0_Params = sk_paint_get_stroke_cap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_stroke_join_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_stroke_join_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_stroke_join_0_Params = sk_paint_get_stroke_join_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_stroke_miter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_stroke_miter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_stroke_miter_0_Params = sk_paint_get_stroke_miter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_stroke_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_stroke_width_0_Params(); + { + ret.paint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_stroke_width_0_Params = sk_paint_get_stroke_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_style_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_style_0_Params = sk_paint_get_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_align_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_align_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_align_0_Params = sk_paint_get_text_align_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_encoding_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_encoding_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_encoding_0_Params = sk_paint_get_text_encoding_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_intercepts_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_intercepts_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.bounds_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.bounds = new Array(); + for (var i = 0; i < ret.bounds_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.bounds.push(Number(value)); + } + } + else { + ret.bounds = null; + } + } + { + ret.intervals = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_intercepts_0_Params = sk_paint_get_text_intercepts_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_path_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_path_0_Params = sk_paint_get_text_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_scale_x_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_scale_x_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_scale_x_0_Params = sk_paint_get_text_scale_x_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_skew_x_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_skew_x_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_skew_x_0_Params = sk_paint_get_text_skew_x_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_text_widths_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_text_widths_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.widths = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.bounds = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_text_widths_0_Params = sk_paint_get_text_widths_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_textsize_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_textsize_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_textsize_0_Params = sk_paint_get_textsize_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_get_typeface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_get_typeface_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_get_typeface_0_Params = sk_paint_get_typeface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_antialias_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_antialias_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_antialias_0_Params = sk_paint_is_antialias_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_autohinted_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_autohinted_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_autohinted_0_Params = sk_paint_is_autohinted_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_dev_kern_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_dev_kern_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_dev_kern_text_0_Params = sk_paint_is_dev_kern_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_dither_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_dither_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_dither_0_Params = sk_paint_is_dither_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_embedded_bitmap_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_embedded_bitmap_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_embedded_bitmap_text_0_Params = sk_paint_is_embedded_bitmap_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_fake_bold_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_fake_bold_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_fake_bold_text_0_Params = sk_paint_is_fake_bold_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_lcd_render_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_lcd_render_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_lcd_render_text_0_Params = sk_paint_is_lcd_render_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_linear_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_linear_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_linear_text_0_Params = sk_paint_is_linear_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_subpixel_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_subpixel_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_subpixel_text_0_Params = sk_paint_is_subpixel_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_is_verticaltext_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_is_verticaltext_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_is_verticaltext_0_Params = sk_paint_is_verticaltext_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_measure_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_measure_text_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.bounds = SkiaSharp.SKRect.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.sk_paint_measure_text_0_Params = sk_paint_measure_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_measure_text_0_Return { + constructor() { + this.bounds = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.bounds.marshal(pData + 0); + } + } + SkiaSharp.sk_paint_measure_text_0_Return = sk_paint_measure_text_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_measure_text_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_measure_text_1_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.boundsZero = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_measure_text_1_Params = sk_paint_measure_text_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_reset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_reset_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_reset_0_Params = sk_paint_reset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_antialias_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_antialias_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.v = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_antialias_0_Params = sk_paint_set_antialias_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_autohinted_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_autohinted_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.useAutohinter = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_autohinted_0_Params = sk_paint_set_autohinted_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_blendmode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_blendmode_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_blendmode_0_Params = sk_paint_set_blendmode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_color_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_paint_set_color_0_Params = sk_paint_set_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_colorfilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_colorfilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filter = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_colorfilter_0_Params = sk_paint_set_colorfilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_dev_kern_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_dev_kern_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.devKernText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_dev_kern_text_0_Params = sk_paint_set_dev_kern_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_dither_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_dither_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.v = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_dither_0_Params = sk_paint_set_dither_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_embedded_bitmap_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_embedded_bitmap_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.useEmbeddedBitmapText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_embedded_bitmap_text_0_Params = sk_paint_set_embedded_bitmap_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_fake_bold_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_fake_bold_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.fakeBoldText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_fake_bold_text_0_Params = sk_paint_set_fake_bold_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_filter_quality_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_filter_quality_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filterQuality = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_filter_quality_0_Params = sk_paint_set_filter_quality_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_hinting_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_hinting_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.hintingLevel = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_hinting_0_Params = sk_paint_set_hinting_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_imagefilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_imagefilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filter = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_imagefilter_0_Params = sk_paint_set_imagefilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_lcd_render_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_lcd_render_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.lcdText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_lcd_render_text_0_Params = sk_paint_set_lcd_render_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_linear_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_linear_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.linearText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_linear_text_0_Params = sk_paint_set_linear_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_maskfilter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_maskfilter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filter = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_maskfilter_0_Params = sk_paint_set_maskfilter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_path_effect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_path_effect_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.effect = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_path_effect_0_Params = sk_paint_set_path_effect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_shader_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_shader_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.shader = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_shader_0_Params = sk_paint_set_shader_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_stroke_cap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_stroke_cap_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cap = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_stroke_cap_0_Params = sk_paint_set_stroke_cap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_stroke_join_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_stroke_join_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.join = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_stroke_join_0_Params = sk_paint_set_stroke_join_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_stroke_miter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_stroke_miter_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.miter = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_stroke_miter_0_Params = sk_paint_set_stroke_miter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_stroke_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_stroke_width_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.width = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_stroke_width_0_Params = sk_paint_set_stroke_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_style_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.style = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_style_0_Params = sk_paint_set_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_subpixel_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_subpixel_text_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.subpixelText = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_subpixel_text_0_Params = sk_paint_set_subpixel_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_text_align_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_text_align_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.align = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_text_align_0_Params = sk_paint_set_text_align_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_text_encoding_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_text_encoding_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.encoding = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_text_encoding_0_Params = sk_paint_set_text_encoding_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_text_scale_x_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_text_scale_x_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.scale = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_text_scale_x_0_Params = sk_paint_set_text_scale_x_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_text_skew_x_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_text_skew_x_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.skew = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_text_skew_x_0_Params = sk_paint_set_text_skew_x_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_textsize_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_textsize_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.size = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_textsize_0_Params = sk_paint_set_textsize_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_typeface_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_typeface_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.typeface = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_typeface_0_Params = sk_paint_set_typeface_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_set_verticaltext_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_set_verticaltext_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.v = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_paint_set_verticaltext_0_Params = sk_paint_set_verticaltext_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_paint_text_to_glyphs_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_paint_text_to_glyphs_0_Params(); + { + ret.cpaint = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.text = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.byteLength = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.glyphs = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_paint_text_to_glyphs_0_Params = sk_paint_text_to_glyphs_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_arc_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_arc_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.sweepAngle = Number(memoryContext.getValue(pData + 24, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_add_arc_0_Params = sk_path_add_arc_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_arc_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_arc_0_Return = sk_path_add_arc_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_circle_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_circle_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.radius = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.dir = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_circle_0_Params = sk_path_add_circle_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_oval_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_oval_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.direction = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_oval_0_Params = sk_path_add_oval_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_oval_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_oval_0_Return = sk_path_add_oval_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_path_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.other = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_path_0_Params = sk_path_add_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_path_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_path_matrix_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.other = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 8); + } + { + ret.mode = Number(memoryContext.getValue(pData + 44, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_path_matrix_0_Params = sk_path_add_path_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_path_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_path_matrix_0_Return = sk_path_add_path_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_path_offset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_path_offset_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.other = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_path_offset_0_Params = sk_path_add_path_offset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_path_reverse_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_path_reverse_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.other = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_add_path_reverse_0_Params = sk_path_add_path_reverse_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_poly_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_poly_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.close = Boolean(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_poly_0_Params = sk_path_add_poly_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.direction = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_rect_0_Params = sk_path_add_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_rect_0_Return = sk_path_add_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rect_start_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_rect_start_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.direction = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.startIndex = Number(memoryContext.getValue(pData + 24, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_rect_start_0_Params = sk_path_add_rect_start_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rect_start_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_rect_start_0_Return = sk_path_add_rect_start_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rounded_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_rounded_rect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.rx = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.ry = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.dir = Number(memoryContext.getValue(pData + 28, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_rounded_rect_0_Params = sk_path_add_rounded_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rounded_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_add_rounded_rect_0_Return = sk_path_add_rounded_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rrect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_rrect_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.direction = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_rrect_0_Params = sk_path_add_rrect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_add_rrect_start_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_add_rrect_start_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.direction = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.startIndex = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_add_rrect_start_0_Params = sk_path_add_rrect_start_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_arc_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_arc_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.ry = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.xAxisRotate = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.largeArc = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.sweep = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.x = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 28, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_arc_to_0_Params = sk_path_arc_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_arc_to_with_oval_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_arc_to_with_oval_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.oval = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.sweepAngle = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.forceMoveTo = Boolean(memoryContext.getValue(pData + 28, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_arc_to_with_oval_0_Params = sk_path_arc_to_with_oval_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_arc_to_with_oval_0_Return { + constructor() { + this.oval = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.oval.marshal(pData + 0); + } + } + SkiaSharp.sk_path_arc_to_with_oval_0_Return = sk_path_arc_to_with_oval_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_arc_to_with_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_arc_to_with_points_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x1 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y1 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.x2 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y2 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.radius = Number(memoryContext.getValue(pData + 20, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_arc_to_with_points_0_Params = sk_path_arc_to_with_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_clone_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_clone_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_clone_0_Params = sk_path_clone_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_close_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_close_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_close_0_Params = sk_path_close_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_compute_tight_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_compute_tight_bounds_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_compute_tight_bounds_0_Params = sk_path_compute_tight_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_compute_tight_bounds_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_compute_tight_bounds_0_Return = sk_path_compute_tight_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_conic_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_conic_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.x1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y1 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.w = Number(memoryContext.getValue(pData + 20, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_conic_to_0_Params = sk_path_conic_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_contains_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_contains_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_contains_0_Params = sk_path_contains_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_convert_conic_to_quads_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_convert_conic_to_quads_0_Params(); + { + ret.p0 = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.p1 = SkiaSharp.SKPoint.unmarshal(pData + 8); + } + { + ret.p2 = SkiaSharp.SKPoint.unmarshal(pData + 16); + } + { + ret.w = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.pts_Length = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 32, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.pts = new Array(); + for (var i = 0; i < ret.pts_Length; i++) { + ret.pts.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.pts = null; + } + } + { + ret.pow2 = Number(memoryContext.getValue(pData + 36, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_convert_conic_to_quads_0_Params = sk_path_convert_conic_to_quads_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_convert_conic_to_quads_0_Return { + constructor() { + this.p0 = new SkiaSharp.SKPoint(); + this.p1 = new SkiaSharp.SKPoint(); + this.p2 = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(24); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.p0.marshal(pData + 0); + this.p1.marshal(pData + 8); + this.p2.marshal(pData + 16); + } + } + SkiaSharp.sk_path_convert_conic_to_quads_0_Return = sk_path_convert_conic_to_quads_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_count_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_count_points_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_count_points_0_Params = sk_path_count_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_count_verbs_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_count_verbs_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_count_verbs_0_Params = sk_path_count_verbs_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_create_iter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_create_iter_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.forceClose = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_create_iter_0_Params = sk_path_create_iter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_create_rawiter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_create_rawiter_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_create_rawiter_0_Params = sk_path_create_rawiter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_cubic_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_cubic_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.x1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y1 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.x2 = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.y2 = Number(memoryContext.getValue(pData + 24, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_cubic_to_0_Params = sk_path_cubic_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_delete_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_delete_0_Params = sk_path_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_1d_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_1d_path_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.advance = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.phase = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.style = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_1d_path_0_Params = sk_path_effect_create_1d_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_2d_line_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_2d_line_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_2d_line_0_Params = sk_path_effect_create_2d_line_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_2d_line_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_path_effect_create_2d_line_0_Return = sk_path_effect_create_2d_line_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_2d_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_2d_path_0_Params(); + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 0); + } + { + ret.path = Number(memoryContext.getValue(pData + 36, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_2d_path_0_Params = sk_path_effect_create_2d_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_2d_path_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_path_effect_create_2d_path_0_Return = sk_path_effect_create_2d_path_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_compose_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_compose_0_Params(); + { + ret.outer = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.inner = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_compose_0_Params = sk_path_effect_create_compose_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_corner_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_corner_0_Params(); + { + ret.radius = Number(memoryContext.getValue(pData + 0, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_corner_0_Params = sk_path_effect_create_corner_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_dash_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_dash_0_Params(); + { + ret.intervals_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.intervals = new Array(); + for (var i = 0; i < ret.intervals_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.intervals.push(Number(value)); + } + } + else { + ret.intervals = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.phase = Number(memoryContext.getValue(pData + 12, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_dash_0_Params = sk_path_effect_create_dash_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_discrete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_discrete_0_Params(); + { + ret.segLength = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.deviation = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.seedAssist = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_discrete_0_Params = sk_path_effect_create_discrete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_sum_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_sum_0_Params(); + { + ret.first = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.second = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_sum_0_Params = sk_path_effect_create_sum_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_create_trim_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_create_trim_0_Params(); + { + ret.start = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.stop = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_create_trim_0_Params = sk_path_effect_create_trim_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_effect_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_effect_unref_0_Params(); + { + ret.effect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_effect_unref_0_Params = sk_path_effect_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_bounds_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_get_bounds_0_Params = sk_path_get_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_bounds_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_path_get_bounds_0_Return = sk_path_get_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_convexity_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_convexity_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_get_convexity_0_Params = sk_path_get_convexity_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_filltype_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_filltype_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_get_filltype_0_Params = sk_path_get_filltype_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_last_point_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_last_point_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_get_last_point_0_Params = sk_path_get_last_point_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_last_point_0_Return { + constructor() { + this.point = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.point.marshal(pData + 0); + } + } + SkiaSharp.sk_path_get_last_point_0_Return = sk_path_get_last_point_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_point_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_point_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_get_point_0_Params = sk_path_get_point_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_point_0_Return { + constructor() { + this.point = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.point.marshal(pData + 0); + } + } + SkiaSharp.sk_path_get_point_0_Return = sk_path_get_point_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_points_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.max = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_get_points_0_Params = sk_path_get_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_get_segment_masks_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_get_segment_masks_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_get_segment_masks_0_Params = sk_path_get_segment_masks_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_line_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_line_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.line_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.line = new Array(); + for (var i = 0; i < ret.line_Length; i++) { + ret.line.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.line = null; + } + } + return ret; + } + } + SkiaSharp.sk_path_is_line_0_Params = sk_path_is_line_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_line_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_line_1_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.lineZero = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_line_1_Params = sk_path_is_line_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_oval_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_oval_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_oval_0_Params = sk_path_is_oval_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_oval_0_Return { + constructor() { + this.bounds = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.bounds.marshal(pData + 0); + } + } + SkiaSharp.sk_path_is_oval_0_Return = sk_path_is_oval_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_oval_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_oval_1_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.boundsZero = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_oval_1_Params = sk_path_is_oval_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_rect_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_rect_0_Params = sk_path_is_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(24); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + memoryContext.setValue(pData + 16, this.isClosed, "i32"); + memoryContext.setValue(pData + 20, this.direction, "i32"); + } + } + SkiaSharp.sk_path_is_rect_0_Return = sk_path_is_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_rect_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_rect_1_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rectZero = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.isClosedZero = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.directionZero = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_rect_1_Params = sk_path_is_rect_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_is_rrect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_is_rrect_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.bounds = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_is_rrect_0_Params = sk_path_is_rrect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_iter_conic_weight_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_iter_conic_weight_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_iter_conic_weight_0_Params = sk_path_iter_conic_weight_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_iter_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_iter_destroy_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_iter_destroy_0_Params = sk_path_iter_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_iter_is_close_line_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_iter_is_close_line_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_iter_is_close_line_0_Params = sk_path_iter_is_close_line_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_iter_is_closed_contour_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_iter_is_closed_contour_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_iter_is_closed_contour_0_Params = sk_path_iter_is_closed_contour_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_iter_next_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_iter_next_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.doConsumeDegenerates = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.exact = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_iter_next_0_Params = sk_path_iter_next_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_line_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_line_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_line_to_0_Params = sk_path_line_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_move_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_move_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_move_to_0_Params = sk_path_move_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_parse_svg_string_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_parse_svg_string_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.str = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.str = null; + } + } + return ret; + } + } + SkiaSharp.sk_path_parse_svg_string_0_Params = sk_path_parse_svg_string_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_quad_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_quad_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.y0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.x1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y1 = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_quad_to_0_Params = sk_path_quad_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rarc_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rarc_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.ry = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.xAxisRotate = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.largeArc = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.sweep = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.x = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 28, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rarc_to_0_Params = sk_path_rarc_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rawiter_conic_weight_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rawiter_conic_weight_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_rawiter_conic_weight_0_Params = sk_path_rawiter_conic_weight_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rawiter_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rawiter_destroy_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_rawiter_destroy_0_Params = sk_path_rawiter_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rawiter_next_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rawiter_next_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.points_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + return ret; + } + } + SkiaSharp.sk_path_rawiter_next_0_Params = sk_path_rawiter_next_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rawiter_peek_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rawiter_peek_0_Params(); + { + ret.iterator = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_rawiter_peek_0_Params = sk_path_rawiter_peek_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rconic_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rconic_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dx1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.dy1 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.w = Number(memoryContext.getValue(pData + 20, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rconic_to_0_Params = sk_path_rconic_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rcubic_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rcubic_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dx1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.dy1 = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.dx2 = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.dy2 = Number(memoryContext.getValue(pData + 24, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rcubic_to_0_Params = sk_path_rcubic_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_reset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_reset_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_reset_0_Params = sk_path_reset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rewind_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rewind_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_rewind_0_Params = sk_path_rewind_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rline_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rline_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rline_to_0_Params = sk_path_rline_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rmove_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rmove_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rmove_to_0_Params = sk_path_rmove_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_rquad_to_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_rquad_to_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx0 = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy0 = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dx1 = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.dy1 = Number(memoryContext.getValue(pData + 16, "float")); + } + return ret; + } + } + SkiaSharp.sk_path_rquad_to_0_Params = sk_path_rquad_to_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_set_convexity_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_set_convexity_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.convexity = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_set_convexity_0_Params = sk_path_set_convexity_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_set_filltype_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_set_filltype_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filltype = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_path_set_filltype_0_Params = sk_path_set_filltype_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_to_svg_string_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_to_svg_string_0_Params(); + { + ret.cpath = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.str = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_path_to_svg_string_0_Params = sk_path_to_svg_string_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_transform_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_path_transform_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_path_transform_0_Params = sk_path_transform_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_path_transform_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_path_transform_0_Return = sk_path_transform_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_destroy_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_destroy_0_Params = sk_pathmeasure_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_length_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_length_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_length_0_Params = sk_pathmeasure_get_length_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_matrix_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.distance = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.flags = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_matrix_0_Params = sk_pathmeasure_get_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_pathmeasure_get_matrix_0_Return = sk_pathmeasure_get_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_pos_tan_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.distance = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_0_Params = sk_pathmeasure_get_pos_tan_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_0_Return { + constructor() { + this.position = new SkiaSharp.SKPoint(); + this.tangent = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.position.marshal(pData + 0); + this.tangent.marshal(pData + 8); + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_0_Return = sk_pathmeasure_get_pos_tan_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_pos_tan_1_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.distance = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.positionZero = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_1_Params = sk_pathmeasure_get_pos_tan_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_1_Return { + constructor() { + this.tangent = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.tangent.marshal(pData + 0); + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_1_Return = sk_pathmeasure_get_pos_tan_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_2_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_pos_tan_2_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.distance = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.tangentZero = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_2_Params = sk_pathmeasure_get_pos_tan_2_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_pos_tan_2_Return { + constructor() { + this.position = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.position.marshal(pData + 0); + } + } + SkiaSharp.sk_pathmeasure_get_pos_tan_2_Return = sk_pathmeasure_get_pos_tan_2_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_get_segment_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_get_segment_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.start = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.stop = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.startWithMoveTo = Boolean(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_get_segment_0_Params = sk_pathmeasure_get_segment_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_is_closed_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_is_closed_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_is_closed_0_Params = sk_pathmeasure_is_closed_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_new_with_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_new_with_path_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.forceClosed = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.resScale = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_new_with_path_0_Params = sk_pathmeasure_new_with_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_next_contour_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_next_contour_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_next_contour_0_Params = sk_pathmeasure_next_contour_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathmeasure_set_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathmeasure_set_path_0_Params(); + { + ret.pathMeasure = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.path = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.forceClosed = Boolean(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pathmeasure_set_path_0_Params = sk_pathmeasure_set_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathop_op_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathop_op_0_Params(); + { + ret.one = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.two = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.result = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathop_op_0_Params = sk_pathop_op_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathop_simplify_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathop_simplify_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.result = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathop_simplify_0_Params = sk_pathop_simplify_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathop_tight_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pathop_tight_bounds_0_Params(); + { + ret.path = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pathop_tight_bounds_0_Params = sk_pathop_tight_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pathop_tight_bounds_0_Return { + constructor() { + this.result = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.result.marshal(pData + 0); + } + } + SkiaSharp.sk_pathop_tight_bounds_0_Return = sk_pathop_tight_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_get_cull_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_get_cull_rect_0_Params(); + { + ret.p = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_get_cull_rect_0_Params = sk_picture_get_cull_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_get_cull_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_picture_get_cull_rect_0_Return = sk_picture_get_cull_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_get_recording_canvas_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_get_recording_canvas_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_get_recording_canvas_0_Params = sk_picture_get_recording_canvas_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_get_unique_id_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_get_unique_id_0_Params(); + { + ret.p = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_get_unique_id_0_Params = sk_picture_get_unique_id_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_recorder_begin_recording_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_recorder_begin_recording_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_picture_recorder_begin_recording_0_Params = sk_picture_recorder_begin_recording_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_recorder_begin_recording_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_picture_recorder_begin_recording_0_Return = sk_picture_recorder_begin_recording_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_recorder_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_recorder_delete_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_recorder_delete_0_Params = sk_picture_recorder_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_recorder_end_recording_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_recorder_end_recording_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_recorder_end_recording_0_Params = sk_picture_recorder_end_recording_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_recorder_end_recording_as_drawable_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_recorder_end_recording_as_drawable_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_recorder_end_recording_as_drawable_0_Params = sk_picture_recorder_end_recording_as_drawable_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_picture_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_picture_unref_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_picture_unref_0_Params = sk_picture_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_destructor_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_destructor_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_destructor_0_Params = sk_pixmap_destructor_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_encode_image_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_encode_image_0_Params(); + { + ret.dst = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.encoder = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.quality = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_encode_image_0_Params = sk_pixmap_encode_image_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_erase_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_erase_color_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 4); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_pixmap_erase_color_0_Params = sk_pixmap_erase_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_erase_color_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_erase_color_0_Return = sk_pixmap_erase_color_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_extract_subset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_extract_subset_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.result = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.subset = SkiaSharp.SKRectI.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_pixmap_extract_subset_0_Params = sk_pixmap_extract_subset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_extract_subset_0_Return { + constructor() { + this.subset = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.subset.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_extract_subset_0_Return = sk_pixmap_extract_subset_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_info_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_get_info_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_get_info_0_Params = sk_pixmap_get_info_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_info_0_Return { + constructor() { + this.cinfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cinfo.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_get_info_0_Return = sk_pixmap_get_info_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_pixel_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_get_pixel_color_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_get_pixel_color_0_Params = sk_pixmap_get_pixel_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_get_pixels_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_get_pixels_0_Params = sk_pixmap_get_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_pixels_with_xy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_get_pixels_with_xy_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_get_pixels_with_xy_0_Params = sk_pixmap_get_pixels_with_xy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_get_row_bytes_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_get_row_bytes_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_get_row_bytes_0_Params = sk_pixmap_get_row_bytes_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_new_with_params_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_new_with_params_0_Params(); + { + ret.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 0); + } + { + ret.addr = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_new_with_params_0_Params = sk_pixmap_new_with_params_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_new_with_params_0_Return { + constructor() { + this.cinfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cinfo.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_new_with_params_0_Return = sk_pixmap_new_with_params_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_read_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_read_pixels_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.dstPixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.dstRowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.srcX = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.srcY = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.behavior = Number(memoryContext.getValue(pData + 40, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_read_pixels_0_Params = sk_pixmap_read_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_read_pixels_0_Return { + constructor() { + this.dstInfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dstInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_read_pixels_0_Return = sk_pixmap_read_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_reset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_reset_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_reset_0_Params = sk_pixmap_reset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_reset_with_params_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_reset_with_params_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.cinfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.addr = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_reset_with_params_0_Params = sk_pixmap_reset_with_params_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_reset_with_params_0_Return { + constructor() { + this.cinfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.cinfo.marshal(pData + 0); + } + } + SkiaSharp.sk_pixmap_reset_with_params_0_Return = sk_pixmap_reset_with_params_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pixmap_scale_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pixmap_scale_pixels_0_Params(); + { + ret.cpixmap = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dst = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.quality = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_pixmap_scale_pixels_0_Params = sk_pixmap_scale_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_pngencoder_encode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_pngencoder_encode_0_Params(); + { + ret.dst = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.options = SkiaSharp.SKPngEncoderOptions.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_pngencoder_encode_0_Params = sk_pngencoder_encode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_contains2_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_contains2_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_region_contains2_0_Params = sk_region_contains2_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_contains_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_contains_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.region = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_contains_0_Params = sk_region_contains_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_get_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_get_bounds_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_get_bounds_0_Params = sk_region_get_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_get_bounds_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_region_get_bounds_0_Return = sk_region_get_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_intersects_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_intersects_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_intersects_0_Params = sk_region_intersects_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_intersects_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_intersects_rect_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_region_intersects_rect_0_Params = sk_region_intersects_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_intersects_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_region_intersects_rect_0_Return = sk_region_intersects_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_new2_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_new2_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_new2_0_Params = sk_region_new2_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_op2_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_op2_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.op = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_region_op2_0_Params = sk_region_op2_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_op_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_op_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.left = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.top = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.right = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.bottom = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.op = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_region_op_0_Params = sk_region_op_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_set_path_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_set_path_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.t = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.clip = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_set_path_0_Params = sk_region_set_path_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_set_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_set_rect_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRectI.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_region_set_rect_0_Params = sk_region_set_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_set_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRectI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_region_set_rect_0_Return = sk_region_set_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_region_set_region_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_region_set_region_0_Params(); + { + ret.r = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_region_set_region_0_Params = sk_region_set_region_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_contains_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_contains_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_rrect_contains_0_Params = sk_rrect_contains_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_contains_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_contains_0_Return = sk_rrect_contains_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_delete_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_delete_0_Params = sk_rrect_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_height_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_get_height_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_get_height_0_Params = sk_rrect_get_height_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_radii_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_get_radii_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.corner = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_rrect_get_radii_0_Params = sk_rrect_get_radii_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_radii_0_Return { + constructor() { + this.radii = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.radii.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_get_radii_0_Return = sk_rrect_get_radii_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_get_rect_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_get_rect_0_Params = sk_rrect_get_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_get_rect_0_Return = sk_rrect_get_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_type_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_get_type_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_get_type_0_Params = sk_rrect_get_type_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_get_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_get_width_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_get_width_0_Params = sk_rrect_get_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_inset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_inset_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_rrect_inset_0_Params = sk_rrect_inset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_is_valid_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_is_valid_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_is_valid_0_Params = sk_rrect_is_valid_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_new_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_new_copy_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_new_copy_0_Params = sk_rrect_new_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_offset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_offset_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_rrect_offset_0_Params = sk_rrect_offset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_outset_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_outset_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dx = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.dy = Number(memoryContext.getValue(pData + 8, "float")); + } + return ret; + } + } + SkiaSharp.sk_rrect_outset_0_Params = sk_rrect_outset_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_empty_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_empty_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_set_empty_0_Params = sk_rrect_set_empty_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_nine_patch_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_nine_patch_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.leftRad = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.topRad = Number(memoryContext.getValue(pData + 24, "float")); + } + { + ret.rightRad = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.bottomRad = Number(memoryContext.getValue(pData + 32, "float")); + } + return ret; + } + } + SkiaSharp.sk_rrect_set_nine_patch_0_Params = sk_rrect_set_nine_patch_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_nine_patch_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_set_nine_patch_0_Return = sk_rrect_set_nine_patch_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_oval_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_oval_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_rrect_set_oval_0_Params = sk_rrect_set_oval_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_oval_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_set_oval_0_Return = sk_rrect_set_oval_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_rect_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_rrect_set_rect_0_Params = sk_rrect_set_rect_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_set_rect_0_Return = sk_rrect_set_rect_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_radii_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_rect_radii_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.radii_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.radii = new Array(); + for (var i = 0; i < ret.radii_Length; i++) { + ret.radii.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.radii = null; + } + } + return ret; + } + } + SkiaSharp.sk_rrect_set_rect_radii_0_Params = sk_rrect_set_rect_radii_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_radii_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_set_rect_radii_0_Return = sk_rrect_set_rect_radii_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_xy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_set_rect_xy_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.rect = SkiaSharp.SKRect.unmarshal(pData + 4); + } + { + ret.xRad = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.yRad = Number(memoryContext.getValue(pData + 24, "float")); + } + return ret; + } + } + SkiaSharp.sk_rrect_set_rect_xy_0_Params = sk_rrect_set_rect_xy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_set_rect_xy_0_Return { + constructor() { + this.rect = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.rect.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_set_rect_xy_0_Return = sk_rrect_set_rect_xy_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_transform_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_rrect_transform_0_Params(); + { + ret.rrect = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + { + ret.dest = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_rrect_transform_0_Params = sk_rrect_transform_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_rrect_transform_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_rrect_transform_0_Return = sk_rrect_transform_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_bitmap_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_bitmap_0_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tmx = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.tmy = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 12); + } + return ret; + } + } + SkiaSharp.sk_shader_new_bitmap_0_Params = sk_shader_new_bitmap_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_bitmap_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_bitmap_0_Return = sk_shader_new_bitmap_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_bitmap_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_bitmap_1_Params(); + { + ret.src = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tmx = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.tmy = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_bitmap_1_Params = sk_shader_new_bitmap_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_color_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_color_0_Params(); + { + ret.color = SkiaSharp.SKColor.unmarshal(pData + 0); + } + return ret; + } + } + SkiaSharp.sk_shader_new_color_0_Params = sk_shader_new_color_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_color_filter_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_color_filter_0_Params(); + { + ret.proxy = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.filter = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_color_filter_0_Params = sk_shader_new_color_filter_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_compose_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_compose_0_Params(); + { + ret.shaderA = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.shaderB = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_compose_0_Params = sk_shader_new_compose_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_compose_with_mode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_compose_with_mode_0_Params(); + { + ret.shaderA = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.shaderB = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_compose_with_mode_0_Params = sk_shader_new_compose_with_mode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_linear_gradient_0_Params(); + { + ret.points_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 32); + } + return ret; + } + } + SkiaSharp.sk_shader_new_linear_gradient_0_Params = sk_shader_new_linear_gradient_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_linear_gradient_0_Return = sk_shader_new_linear_gradient_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_linear_gradient_1_Params(); + { + ret.points_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_linear_gradient_1_Params = sk_shader_new_linear_gradient_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_2_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_linear_gradient_2_Params(); + { + ret.points_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 28); + } + return ret; + } + } + SkiaSharp.sk_shader_new_linear_gradient_2_Params = sk_shader_new_linear_gradient_2_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_2_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_linear_gradient_2_Return = sk_shader_new_linear_gradient_2_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_linear_gradient_3_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_linear_gradient_3_Params(); + { + ret.points_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.points = new Array(); + for (var i = 0; i < ret.points_Length; i++) { + ret.points.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.points = null; + } + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_linear_gradient_3_Params = sk_shader_new_linear_gradient_3_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_local_matrix_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_local_matrix_0_Params(); + { + ret.proxy = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 4); + } + return ret; + } + } + SkiaSharp.sk_shader_new_local_matrix_0_Params = sk_shader_new_local_matrix_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_local_matrix_0_Return { + constructor() { + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(36); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.matrix.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_local_matrix_0_Return = sk_shader_new_local_matrix_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_fractal_noise_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_perlin_noise_fractal_noise_0_Params(); + { + ret.baseFrequencyX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.baseFrequencyY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.numOctaves = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.seed = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.tileSizeZero = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_0_Params = sk_shader_new_perlin_noise_fractal_noise_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_fractal_noise_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_perlin_noise_fractal_noise_1_Params(); + { + ret.baseFrequencyX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.baseFrequencyY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.numOctaves = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.seed = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.tileSize = SkiaSharp.SKPointI.unmarshal(pData + 16); + } + return ret; + } + } + SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_1_Params = sk_shader_new_perlin_noise_fractal_noise_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_fractal_noise_1_Return { + constructor() { + this.tileSize = new SkiaSharp.SKPointI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.tileSize.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_perlin_noise_fractal_noise_1_Return = sk_shader_new_perlin_noise_fractal_noise_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_turbulence_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_perlin_noise_turbulence_0_Params(); + { + ret.baseFrequencyX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.baseFrequencyY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.numOctaves = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.seed = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.tileSizeZero = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_perlin_noise_turbulence_0_Params = sk_shader_new_perlin_noise_turbulence_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_turbulence_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_perlin_noise_turbulence_1_Params(); + { + ret.baseFrequencyX = Number(memoryContext.getValue(pData + 0, "float")); + } + { + ret.baseFrequencyY = Number(memoryContext.getValue(pData + 4, "float")); + } + { + ret.numOctaves = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.seed = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.tileSize = SkiaSharp.SKPointI.unmarshal(pData + 16); + } + return ret; + } + } + SkiaSharp.sk_shader_new_perlin_noise_turbulence_1_Params = sk_shader_new_perlin_noise_turbulence_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_perlin_noise_turbulence_1_Return { + constructor() { + this.tileSize = new SkiaSharp.SKPointI(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.tileSize.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_perlin_noise_turbulence_1_Return = sk_shader_new_perlin_noise_turbulence_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_radial_gradient_0_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.radius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 36); + } + return ret; + } + } + SkiaSharp.sk_shader_new_radial_gradient_0_Params = sk_shader_new_radial_gradient_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_0_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.matrix.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_radial_gradient_0_Return = sk_shader_new_radial_gradient_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_radial_gradient_1_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.radius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 24, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 36, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_radial_gradient_1_Params = sk_shader_new_radial_gradient_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_1_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_radial_gradient_1_Return = sk_shader_new_radial_gradient_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_2_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_radial_gradient_2_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.radius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 32); + } + return ret; + } + } + SkiaSharp.sk_shader_new_radial_gradient_2_Params = sk_shader_new_radial_gradient_2_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_2_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.matrix.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_radial_gradient_2_Return = sk_shader_new_radial_gradient_2_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_3_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_radial_gradient_3_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.radius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 16, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 32, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_radial_gradient_3_Params = sk_shader_new_radial_gradient_3_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_radial_gradient_3_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_radial_gradient_3_Return = sk_shader_new_radial_gradient_3_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_sweep_gradient_0_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.endAngle = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 40, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_sweep_gradient_0_Params = sk_shader_new_sweep_gradient_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_0_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_sweep_gradient_0_Return = sk_shader_new_sweep_gradient_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_sweep_gradient_1_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.endAngle = Number(memoryContext.getValue(pData + 36, "float")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 40); + } + return ret; + } + } + SkiaSharp.sk_shader_new_sweep_gradient_1_Params = sk_shader_new_sweep_gradient_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_1_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.matrix.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_sweep_gradient_1_Return = sk_shader_new_sweep_gradient_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_2_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_sweep_gradient_2_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.endAngle = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 36, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_sweep_gradient_2_Params = sk_shader_new_sweep_gradient_2_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_2_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(8); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + } + } + SkiaSharp.sk_shader_new_sweep_gradient_2_Return = sk_shader_new_sweep_gradient_2_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_3_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_sweep_gradient_3_Params(); + { + ret.center = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + ret.startAngle = Number(memoryContext.getValue(pData + 28, "float")); + } + { + ret.endAngle = Number(memoryContext.getValue(pData + 32, "float")); + } + { + ret.matrixZero = SkiaSharp.SKMatrix.unmarshal(pData + 36); + } + return ret; + } + } + SkiaSharp.sk_shader_new_sweep_gradient_3_Params = sk_shader_new_sweep_gradient_3_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_sweep_gradient_3_Return { + constructor() { + this.center = new SkiaSharp.SKPoint(); + this.matrixZero = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(44); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.center.marshal(pData + 0); + this.matrixZero.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_sweep_gradient_3_Return = sk_shader_new_sweep_gradient_3_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_two_point_conical_gradient_0_Params(); + { + ret.start = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.startRadius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.end = SkiaSharp.SKPoint.unmarshal(pData + 12); + } + { + ret.endRadius = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 36, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 40, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 44, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 48); + } + return ret; + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_0_Params = sk_shader_new_two_point_conical_gradient_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_0_Return { + constructor() { + this.start = new SkiaSharp.SKPoint(); + this.end = new SkiaSharp.SKPoint(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(52); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.start.marshal(pData + 0); + this.end.marshal(pData + 8); + this.matrix.marshal(pData + 16); + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_0_Return = sk_shader_new_two_point_conical_gradient_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_two_point_conical_gradient_1_Params(); + { + ret.start = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.startRadius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.end = SkiaSharp.SKPoint.unmarshal(pData + 12); + } + { + ret.endRadius = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPos_Length = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 36, "*"); /*float 4 False*/ + if (pArray !== 0) { + ret.colorPos = new Array(); + for (var i = 0; i < ret.colorPos_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "float"); + ret.colorPos.push(Number(value)); + } + } + else { + ret.colorPos = null; + } + } + { + ret.count = Number(memoryContext.getValue(pData + 40, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 44, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 48, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_1_Params = sk_shader_new_two_point_conical_gradient_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_1_Return { + constructor() { + this.start = new SkiaSharp.SKPoint(); + this.end = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.start.marshal(pData + 0); + this.end.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_1_Return = sk_shader_new_two_point_conical_gradient_1_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_2_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_two_point_conical_gradient_2_Params(); + { + ret.start = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.startRadius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.end = SkiaSharp.SKPoint.unmarshal(pData + 12); + } + { + ret.endRadius = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 32, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 40, "i32")); + } + { + ret.matrix = SkiaSharp.SKMatrix.unmarshal(pData + 44); + } + return ret; + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_2_Params = sk_shader_new_two_point_conical_gradient_2_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_2_Return { + constructor() { + this.start = new SkiaSharp.SKPoint(); + this.end = new SkiaSharp.SKPoint(); + this.matrix = new SkiaSharp.SKMatrix(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(52); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.start.marshal(pData + 0); + this.end.marshal(pData + 8); + this.matrix.marshal(pData + 16); + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_2_Return = sk_shader_new_two_point_conical_gradient_2_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_3_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_new_two_point_conical_gradient_3_Params(); + { + ret.start = SkiaSharp.SKPoint.unmarshal(pData + 0); + } + { + ret.startRadius = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.end = SkiaSharp.SKPoint.unmarshal(pData + 12); + } + { + ret.endRadius = Number(memoryContext.getValue(pData + 20, "float")); + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.colorPosZero = Number(memoryContext.getValue(pData + 32, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + ret.mode = Number(memoryContext.getValue(pData + 40, "i32")); + } + { + ret.matrixZero = Number(memoryContext.getValue(pData + 44, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_3_Params = sk_shader_new_two_point_conical_gradient_3_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_new_two_point_conical_gradient_3_Return { + constructor() { + this.start = new SkiaSharp.SKPoint(); + this.end = new SkiaSharp.SKPoint(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.start.marshal(pData + 0); + this.end.marshal(pData + 8); + } + } + SkiaSharp.sk_shader_new_two_point_conical_gradient_3_Return = sk_shader_new_two_point_conical_gradient_3_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_shader_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_shader_unref_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_shader_unref_0_Params = sk_shader_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_asset_destroy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_asset_destroy_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_asset_destroy_0_Params = sk_stream_asset_destroy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_get_length_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_get_length_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_get_length_0_Params = sk_stream_get_length_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_get_memory_base_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_get_memory_base_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_get_memory_base_0_Params = sk_stream_get_memory_base_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_get_position_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_get_position_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_get_position_0_Params = sk_stream_get_position_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_has_length_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_has_length_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_has_length_0_Params = sk_stream_has_length_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_has_position_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_has_position_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_has_position_0_Params = sk_stream_has_position_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_is_at_end_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_is_at_end_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_is_at_end_0_Params = sk_stream_is_at_end_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_move_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_move_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.offset = Number(memoryContext.getValue(pData + 4, "i64")); + } + return ret; + } + } + SkiaSharp.sk_stream_move_0_Params = sk_stream_move_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_peek_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_peek_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.buffer = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.size = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_peek_0_Params = sk_stream_peek_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.buffer = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.size = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_0_Params = sk_stream_read_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_bool_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_bool_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_bool_0_Params = sk_stream_read_bool_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_bool_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i32"); + } + } + SkiaSharp.sk_stream_read_bool_0_Return = sk_stream_read_bool_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s16_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_s16_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_s16_0_Params = sk_stream_read_s16_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s16_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i16"); + } + } + SkiaSharp.sk_stream_read_s16_0_Return = sk_stream_read_s16_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s32_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_s32_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_s32_0_Params = sk_stream_read_s32_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s32_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i32"); + } + } + SkiaSharp.sk_stream_read_s32_0_Return = sk_stream_read_s32_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s8_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_s8_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_s8_0_Params = sk_stream_read_s8_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_s8_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i8"); + } + } + SkiaSharp.sk_stream_read_s8_0_Return = sk_stream_read_s8_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u16_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_u16_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_u16_0_Params = sk_stream_read_u16_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u16_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i16"); + } + } + SkiaSharp.sk_stream_read_u16_0_Return = sk_stream_read_u16_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u32_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_u32_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_u32_0_Params = sk_stream_read_u32_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u32_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i32"); + } + } + SkiaSharp.sk_stream_read_u32_0_Return = sk_stream_read_u32_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u8_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_read_u8_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_read_u8_0_Params = sk_stream_read_u8_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_read_u8_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.buffer, "i8"); + } + } + SkiaSharp.sk_stream_read_u8_0_Return = sk_stream_read_u8_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_rewind_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_rewind_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_rewind_0_Params = sk_stream_rewind_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_seek_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_seek_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.position = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_seek_0_Params = sk_stream_seek_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_stream_skip_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_stream_skip_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.size = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_stream_skip_0_Params = sk_stream_skip_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_string_destructor_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_string_destructor_0_Params(); + { + ret.skstring = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_string_destructor_0_Params = sk_string_destructor_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_string_get_c_str_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_string_get_c_str_0_Params(); + { + ret.skstring = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_string_get_c_str_0_Params = sk_string_get_c_str_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_string_get_size_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_string_get_size_0_Params(); + { + ret.skstring = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_string_get_size_0_Params = sk_string_get_size_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_string_new_with_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_string_new_with_copy_0_Params(); + { + ret.src_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.src = new Array(); + for (var i = 0; i < ret.src_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.src.push(Number(value)); + } + } + else { + ret.src = null; + } + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_string_new_with_copy_0_Params = sk_string_new_with_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_draw_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_draw_0_Params(); + { + ret.surface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.canvas = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.x = Number(memoryContext.getValue(pData + 8, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.paint = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_draw_0_Params = sk_surface_draw_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_get_canvas_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_get_canvas_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_get_canvas_0_Params = sk_surface_get_canvas_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_get_props_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_get_props_0_Params(); + { + ret.surface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_get_props_0_Params = sk_surface_get_props_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_backend_render_target_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_backend_render_target_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.target = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.colorspace = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.props = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_backend_render_target_0_Params = sk_surface_new_backend_render_target_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_backend_texture_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_backend_texture_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.texture = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.samples = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.colorspace = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.props = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_backend_texture_0_Params = sk_surface_new_backend_texture_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_backend_texture_as_render_target_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_backend_texture_as_render_target_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.texture = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.samples = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.colorType = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.colorspace = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.props = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_backend_texture_as_render_target_0_Params = sk_surface_new_backend_texture_as_render_target_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_image_snapshot_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_image_snapshot_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_image_snapshot_0_Params = sk_surface_new_image_snapshot_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_null_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_null_0_Params(); + { + ret.width = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.height = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_null_0_Params = sk_surface_new_null_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_raster_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_raster_0_Params(); + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 0); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.props = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_raster_0_Params = sk_surface_new_raster_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_raster_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_surface_new_raster_0_Return = sk_surface_new_raster_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_raster_direct_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_raster_direct_0_Params(); + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 0); + } + { + ret.pixels = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.rowBytes = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.releaseProc = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.context = Number(memoryContext.getValue(pData + 32, "*")); + } + { + ret.props = Number(memoryContext.getValue(pData + 36, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_raster_direct_0_Params = sk_surface_new_raster_direct_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_raster_direct_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_surface_new_raster_direct_0_Return = sk_surface_new_raster_direct_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_render_target_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_new_render_target_0_Params(); + { + ret.context = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.budgeted = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.info = SkiaSharp.SKImageInfoNative.unmarshal(pData + 8); + } + { + ret.sampleCount = Number(memoryContext.getValue(pData + 28, "i32")); + } + { + ret.origin = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.props = Number(memoryContext.getValue(pData + 36, "*")); + } + { + ret.shouldCreateWithMips = Boolean(memoryContext.getValue(pData + 40, "i32")); + } + return ret; + } + } + SkiaSharp.sk_surface_new_render_target_0_Params = sk_surface_new_render_target_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_new_render_target_0_Return { + constructor() { + this.info = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.info.marshal(pData + 0); + } + } + SkiaSharp.sk_surface_new_render_target_0_Return = sk_surface_new_render_target_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_peek_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_peek_pixels_0_Params(); + { + ret.surface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.pixmap = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_peek_pixels_0_Params = sk_surface_peek_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_read_pixels_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_read_pixels_0_Params(); + { + ret.surface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.dstInfo = SkiaSharp.SKImageInfoNative.unmarshal(pData + 4); + } + { + ret.dstPixels = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.dstRowBytes = Number(memoryContext.getValue(pData + 28, "*")); + } + { + ret.srcX = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.srcY = Number(memoryContext.getValue(pData + 36, "i32")); + } + return ret; + } + } + SkiaSharp.sk_surface_read_pixels_0_Params = sk_surface_read_pixels_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_read_pixels_0_Return { + constructor() { + this.dstInfo = new SkiaSharp.SKImageInfoNative(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(20); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.dstInfo.marshal(pData + 0); + } + } + SkiaSharp.sk_surface_read_pixels_0_Return = sk_surface_read_pixels_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surface_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surface_unref_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surface_unref_0_Params = sk_surface_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surfaceprops_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surfaceprops_delete_0_Params(); + { + ret.props = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surfaceprops_delete_0_Params = sk_surfaceprops_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surfaceprops_get_flags_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surfaceprops_get_flags_0_Params(); + { + ret.props = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surfaceprops_get_flags_0_Params = sk_surfaceprops_get_flags_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surfaceprops_get_pixel_geometry_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surfaceprops_get_pixel_geometry_0_Params(); + { + ret.props = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_surfaceprops_get_pixel_geometry_0_Params = sk_surfaceprops_get_pixel_geometry_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_surfaceprops_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_surfaceprops_new_0_Params(); + { + ret.flags = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.geometry = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_surfaceprops_new_0_Params = sk_surfaceprops_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_svgcanvas_create_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_svgcanvas_create_0_Params(); + { + ret.bounds = SkiaSharp.SKRect.unmarshal(pData + 0); + } + { + ret.writer = Number(memoryContext.getValue(pData + 16, "*")); + } + return ret; + } + } + SkiaSharp.sk_svgcanvas_create_0_Params = sk_svgcanvas_create_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_svgcanvas_create_0_Return { + constructor() { + this.bounds = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.bounds.marshal(pData + 0); + } + } + SkiaSharp.sk_svgcanvas_create_0_Return = sk_svgcanvas_create_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_swizzle_swap_rb_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_swizzle_swap_rb_0_Params(); + { + ret.dest = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_swizzle_swap_rb_0_Params = sk_swizzle_swap_rb_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_alloc_run_text_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.font = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.x = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.y = Number(memoryContext.getValue(pData + 16, "float")); + } + { + ret.textByteCount = Number(memoryContext.getValue(pData + 20, "i32")); + } + { + ret.lang = Number(memoryContext.getValue(pData + 24, "*")); + } + { + ret.bounds = Number(memoryContext.getValue(pData + 28, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_0_Params = sk_textblob_builder_alloc_run_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_0_Return { + constructor() { + this.runbuffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.runbuffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_0_Return = sk_textblob_builder_alloc_run_text_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_pos_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_alloc_run_text_pos_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.font = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.textByteCount = Number(memoryContext.getValue(pData + 12, "i32")); + } + { + ret.lang = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.bounds = Number(memoryContext.getValue(pData + 20, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_pos_0_Params = sk_textblob_builder_alloc_run_text_pos_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_pos_0_Return { + constructor() { + this.runbuffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.runbuffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_pos_0_Return = sk_textblob_builder_alloc_run_text_pos_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_pos_h_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_alloc_run_text_pos_h_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.font = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.y = Number(memoryContext.getValue(pData + 12, "float")); + } + { + ret.textByteCount = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + ret.lang = Number(memoryContext.getValue(pData + 20, "*")); + } + { + ret.bounds = Number(memoryContext.getValue(pData + 24, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_pos_h_0_Params = sk_textblob_builder_alloc_run_text_pos_h_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_alloc_run_text_pos_h_0_Return { + constructor() { + this.runbuffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.runbuffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_alloc_run_text_pos_h_0_Return = sk_textblob_builder_alloc_run_text_pos_h_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_delete_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_delete_0_Params = sk_textblob_builder_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_make_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_make_0_Params(); + { + ret.builder = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_make_0_Params = sk_textblob_builder_make_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_clusters_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_runbuffer_set_clusters_0_Params(); + { + ret.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(pData + 0); + } + { + ret.clusters = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_clusters_0_Params = sk_textblob_builder_runbuffer_set_clusters_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_clusters_0_Return { + constructor() { + this.buffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.buffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_clusters_0_Return = sk_textblob_builder_runbuffer_set_clusters_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_glyphs_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_runbuffer_set_glyphs_0_Params(); + { + ret.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(pData + 0); + } + { + ret.glyphs = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_glyphs_0_Params = sk_textblob_builder_runbuffer_set_glyphs_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_glyphs_0_Return { + constructor() { + this.buffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.buffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_glyphs_0_Return = sk_textblob_builder_runbuffer_set_glyphs_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_pos_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_runbuffer_set_pos_0_Params(); + { + ret.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(pData + 0); + } + { + ret.pos = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_pos_0_Params = sk_textblob_builder_runbuffer_set_pos_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_pos_0_Return { + constructor() { + this.buffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.buffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_pos_0_Return = sk_textblob_builder_runbuffer_set_pos_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_pos_points_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_runbuffer_set_pos_points_0_Params(); + { + ret.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(pData + 0); + } + { + ret.pos = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_pos_points_0_Params = sk_textblob_builder_runbuffer_set_pos_points_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_pos_points_0_Return { + constructor() { + this.buffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.buffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_pos_points_0_Return = sk_textblob_builder_runbuffer_set_pos_points_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_utf8_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_builder_runbuffer_set_utf8_text_0_Params(); + { + ret.buffer = SkiaSharp.SKTextBlobBuilderRunBuffer.unmarshal(pData + 0); + } + { + ret.text = Number(memoryContext.getValue(pData + 16, "*")); + } + { + ret.count = Number(memoryContext.getValue(pData + 20, "i32")); + } + return ret; + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_utf8_text_0_Params = sk_textblob_builder_runbuffer_set_utf8_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_builder_runbuffer_set_utf8_text_0_Return { + constructor() { + this.buffer = new SkiaSharp.SKTextBlobBuilderRunBuffer(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.buffer.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_builder_runbuffer_set_utf8_text_0_Return = sk_textblob_builder_runbuffer_set_utf8_text_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_get_bounds_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_get_bounds_0_Params(); + { + ret.blob = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_get_bounds_0_Params = sk_textblob_get_bounds_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_get_bounds_0_Return { + constructor() { + this.bounds = new SkiaSharp.SKRect(); + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(16); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + this.bounds.marshal(pData + 0); + } + } + SkiaSharp.sk_textblob_get_bounds_0_Return = sk_textblob_get_bounds_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_get_unique_id_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_get_unique_id_0_Params(); + { + ret.blob = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_get_unique_id_0_Params = sk_textblob_get_unique_id_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_ref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_ref_0_Params(); + { + ret.blob = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_ref_0_Params = sk_textblob_ref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_textblob_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_textblob_unref_0_Params(); + { + ret.blob = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_textblob_unref_0_Params = sk_textblob_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_chars_to_glyphs_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_chars_to_glyphs_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.chars = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.encoding = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + ret.glyphPtr = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.glyphCount = Number(memoryContext.getValue(pData + 16, "i32")); + } + return ret; + } + } + SkiaSharp.sk_typeface_chars_to_glyphs_0_Params = sk_typeface_chars_to_glyphs_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_count_tables_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_count_tables_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_count_tables_0_Params = sk_typeface_count_tables_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_create_from_file_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_create_from_file_0_Params(); + { + ret.utf8path_Length = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 4, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.utf8path = new Array(); + for (var i = 0; i < ret.utf8path_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.utf8path.push(Number(value)); + } + } + else { + ret.utf8path = null; + } + } + { + ret.index = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_typeface_create_from_file_0_Params = sk_typeface_create_from_file_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_create_from_name_with_font_style_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_create_from_name_with_font_style_0_Params(); + { + var ptr = memoryContext.getValue(pData + 0, "*"); + if (ptr !== 0) { + ret.familyName = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.familyName = null; + } + } + { + ret.style = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_create_from_name_with_font_style_0_Params = sk_typeface_create_from_name_with_font_style_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_create_from_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_create_from_stream_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.index = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_typeface_create_from_stream_0_Params = sk_typeface_create_from_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_family_name_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_family_name_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_family_name_0_Params = sk_typeface_get_family_name_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_font_slant_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_font_slant_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_font_slant_0_Params = sk_typeface_get_font_slant_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_font_weight_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_font_weight_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_font_weight_0_Params = sk_typeface_get_font_weight_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_font_width_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_font_width_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_font_width_0_Params = sk_typeface_get_font_width_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_fontstyle_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_fontstyle_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_fontstyle_0_Params = sk_typeface_get_fontstyle_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_table_data_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_table_data_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tag = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.offset = Number(memoryContext.getValue(pData + 8, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 12, "*")); + } + { + ret.data_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.data = new Array(); + for (var i = 0; i < ret.data_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.data.push(Number(value)); + } + } + else { + ret.data = null; + } + } + return ret; + } + } + SkiaSharp.sk_typeface_get_table_data_0_Params = sk_typeface_get_table_data_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_table_size_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_table_size_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tag = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_table_size_0_Params = sk_typeface_get_table_size_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_table_tags_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_table_tags_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.tags_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*uint 4 False*/ + if (pArray !== 0) { + ret.tags = new Array(); + for (var i = 0; i < ret.tags_Length; i++) { + var value = memoryContext.getValue(pArray + i * 4, "i32"); + ret.tags.push(Number(value)); + } + } + else { + ret.tags = null; + } + } + return ret; + } + } + SkiaSharp.sk_typeface_get_table_tags_0_Params = sk_typeface_get_table_tags_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_get_units_per_em_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_get_units_per_em_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_get_units_per_em_0_Params = sk_typeface_get_units_per_em_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_open_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_open_stream_0_Params(); + { + ret.typeface = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_open_stream_0_Params = sk_typeface_open_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_open_stream_0_Return { + constructor() { + } + marshalNew(memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + var pTarget = memoryContext._malloc(4); + this.marshal(pTarget, memoryContext); + return pTarget; + } + marshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + memoryContext.setValue(pData + 0, this.ttcIndex, "i32"); + } + } + SkiaSharp.sk_typeface_open_stream_0_Return = sk_typeface_open_stream_0_Return; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_typeface_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_typeface_unref_0_Params(); + { + ret.t = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_typeface_unref_0_Params = sk_typeface_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_vertices_make_copy_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_vertices_make_copy_0_Params(); + { + ret.vmode = Number(memoryContext.getValue(pData + 0, "i32")); + } + { + ret.vertexCount = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.positions_Length = Number(memoryContext.getValue(pData + 8, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 12, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.positions = new Array(); + for (var i = 0; i < ret.positions_Length; i++) { + ret.positions.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.positions = null; + } + } + { + ret.texs_Length = Number(memoryContext.getValue(pData + 16, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 20, "*"); /*SkiaSharp.SKPoint 4 False*/ + if (pArray !== 0) { + ret.texs = new Array(); + for (var i = 0; i < ret.texs_Length; i++) { + ret.texs.push(SkiaSharp.SKPoint.unmarshal(pArray + i * 4)); + } + } + else { + ret.texs = null; + } + } + { + ret.colors_Length = Number(memoryContext.getValue(pData + 24, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 28, "*"); /*SkiaSharp.SKColor 4 False*/ + if (pArray !== 0) { + ret.colors = new Array(); + for (var i = 0; i < ret.colors_Length; i++) { + ret.colors.push(SkiaSharp.SKColor.unmarshal(pArray + i * 4)); + } + } + else { + ret.colors = null; + } + } + { + ret.indexCount = Number(memoryContext.getValue(pData + 32, "i32")); + } + { + ret.indices_Length = Number(memoryContext.getValue(pData + 36, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 40, "*"); /*ushort 2 False*/ + if (pArray !== 0) { + ret.indices = new Array(); + for (var i = 0; i < ret.indices_Length; i++) { + var value = memoryContext.getValue(pArray + i * 2, "i16"); + ret.indices.push(Number(value)); + } + } + else { + ret.indices = null; + } + } + return ret; + } + } + SkiaSharp.sk_vertices_make_copy_0_Params = sk_vertices_make_copy_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_vertices_unref_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_vertices_unref_0_Params(); + { + ret.cvertices = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_vertices_unref_0_Params = sk_vertices_unref_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_webpencoder_encode_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_webpencoder_encode_0_Params(); + { + ret.dst = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.src = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.options = SkiaSharp.SKWebpEncoderOptions.unmarshal(pData + 8); + } + return ret; + } + } + SkiaSharp.sk_webpencoder_encode_0_Params = sk_webpencoder_encode_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_bytes_written_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_bytes_written_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_bytes_written_0_Params = sk_wstream_bytes_written_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_flush_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_flush_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_flush_0_Params = sk_wstream_flush_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_get_size_of_packed_uint_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_get_size_of_packed_uint_0_Params(); + { + ret.value = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_get_size_of_packed_uint_0_Params = sk_wstream_get_size_of_packed_uint_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_newline_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_newline_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_newline_0_Params = sk_wstream_newline_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.buffer = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.size = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_0_Params = sk_wstream_write_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_16_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_16_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i16")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_16_0_Params = sk_wstream_write_16_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_1_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_1_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.buffer_Length = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + var pArray = memoryContext.getValue(pData + 8, "*"); /*byte 1 False*/ + if (pArray !== 0) { + ret.buffer = new Array(); + for (var i = 0; i < ret.buffer_Length; i++) { + var value = memoryContext.getValue(pArray + i * 1, "i8"); + ret.buffer.push(Number(value)); + } + } + else { + ret.buffer = null; + } + } + { + ret.size = Number(memoryContext.getValue(pData + 12, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_1_Params = sk_wstream_write_1_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_32_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_32_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_32_0_Params = sk_wstream_write_32_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_8_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_8_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i8")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_8_0_Params = sk_wstream_write_8_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_bigdec_as_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_bigdec_as_text_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i64")); + } + { + ret.minDigits = Number(memoryContext.getValue(pData + 12, "i32")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_bigdec_as_text_0_Params = sk_wstream_write_bigdec_as_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_bool_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_bool_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Boolean(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_bool_0_Params = sk_wstream_write_bool_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_dec_as_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_dec_as_text_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i32")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_dec_as_text_0_Params = sk_wstream_write_dec_as_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_hex_as_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_hex_as_text_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "i32")); + } + { + ret.minDigits = Number(memoryContext.getValue(pData + 8, "i32")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_hex_as_text_0_Params = sk_wstream_write_hex_as_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_packed_uint_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_packed_uint_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_packed_uint_0_Params = sk_wstream_write_packed_uint_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_scalar_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_scalar_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_scalar_0_Params = sk_wstream_write_scalar_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_scalar_as_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_scalar_as_text_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.value = Number(memoryContext.getValue(pData + 4, "float")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_scalar_as_text_0_Params = sk_wstream_write_scalar_as_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_stream_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_stream_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + ret.input = Number(memoryContext.getValue(pData + 4, "*")); + } + { + ret.length = Number(memoryContext.getValue(pData + 8, "*")); + } + return ret; + } + } + SkiaSharp.sk_wstream_write_stream_0_Params = sk_wstream_write_stream_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_wstream_write_text_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_wstream_write_text_0_Params(); + { + ret.cstream = Number(memoryContext.getValue(pData + 0, "*")); + } + { + var ptr = memoryContext.getValue(pData + 4, "*"); + if (ptr !== 0) { + ret.value = String(memoryContext.UTF8ToString(ptr)); + } + else { + ret.value = null; + } + } + return ret; + } + } + SkiaSharp.sk_wstream_write_text_0_Params = sk_wstream_write_text_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_xmlstreamwriter_delete_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_xmlstreamwriter_delete_0_Params(); + { + ret.writer = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_xmlstreamwriter_delete_0_Params = sk_xmlstreamwriter_delete_0_Params; +})(SkiaSharp || (SkiaSharp = {})); +/* TSBindingsGenerator Generated code -- this code is regenerated on each build */ +var SkiaSharp; +(function (SkiaSharp) { + class sk_xmlstreamwriter_new_0_Params { + static unmarshal(pData, memoryContext = null) { + memoryContext = memoryContext ? memoryContext : Module; + let ret = new sk_xmlstreamwriter_new_0_Params(); + { + ret.stream = Number(memoryContext.getValue(pData + 0, "*")); + } + return ret; + } + } + SkiaSharp.sk_xmlstreamwriter_new_0_Params = sk_xmlstreamwriter_new_0_Params; +})(SkiaSharp || (SkiaSharp = {})); diff --git a/dis/VSTemplate/WebAsm/Scripts/loading.js b/dis/VSTemplate/WebAsm/Scripts/loading.js new file mode 100644 index 000000000..ebe5f077b --- /dev/null +++ b/dis/VSTemplate/WebAsm/Scripts/loading.js @@ -0,0 +1,144 @@ +window.addEventListener("DOMContentLoaded", init); + +function init() { + LaFuInsertStartScreen("feedback-body"); +} +//// Startanimation helpers + +var LaFuDivContainer = null; +var LaFuProgressState = 0; +var LaFuAnimStartTime = 0.0; +var LaFuAnimDuration = 500.0; +var LaFuTextMessages = ["LOADING", "INITIALIZING", "MADE WITH"] +var LaFuProgressSteps = [0.5, 0.66, 10]; +var LaFuNextThreshold = 0; +// Preload the rocket animation +var rocketAnimImg = new Image(); +rocketAnimImg.src = "Assets/FuseeAnim.gif"; + +function LaFuInitAnim() { + LaFuAnimStartTime = window.performance.now(); +} + +function LaFuStartRocket() { + if (document.getElementById("LaFuProgressText")) + document.getElementById("LaFuProgressText").style.opacity = 0; + + animTime = window.performance.now() - LaFuAnimStartTime; + restTime = LaFuAnimDuration - animTime % LaFuAnimDuration; + window.setTimeout(LaFuDoChangeImage, restTime); +} + +function LaFuDoChangeImage() { + LaFuNextText(2400); + window.setTimeout(LaFuShowFuseeText, 2400); + document.getElementById("LaFusee").src = "Assets/FuseeAnim.gif"; + window.setTimeout(LaFuRemoveAllLoading, 3500); +} + +function LaFuRemoveAllLoading() { + var feedback = document.getElementById("feedback-body"); + feedback.parentElement.removeChild(feedback); +} + + +function LaFuShowFuseeText() { + document.getElementById("LaFuseeTxt").style.opacity = 1.0; +} + +function LaFuNextText(timeout) { + LaFuProgressState++; + if (LaFuProgressState >= LaFuTextMessages.length) + LaFuProgressState = LaFuTextMessages.length - 1; + document.getElementById("LaFuProgressText").style.opacity = 0; + window.setTimeout(LaFuDoChangeText, timeout); +} + +function LaFuDoChangeText() { + document.getElementById("LaFuProgressText").innerText = LaFuTextMessages[LaFuProgressState]; + document.getElementById("LaFuProgressText").style.opacity = 1; +} + +function LaFuSetProgress(progress) { + if (progress > LaFuProgressSteps[LaFuNextThreshold]) { + LaFuAdvanceProgress(); + LaFuNextThreshold++; + if (LaFuNextThreshold >= LaFuProgressSteps.length) + LaFuNextThreshold = LaFuProgressSteps.length - 1; + } +} + +function LaFuAdvanceProgress() { + switch (LaFuProgressState) { + case 0: + LaFuNextText(500); + break; + case 1: + LaFuStartRocket(); + break; + } +} + +function LaFuInsertStartScreen(someElementId) { + LaFuDivContainer = document.getElementById(someElementId); + LaFuDivContainer.innerHTML += "\ + \ + \ +
\ +

LOADING

"; +} + + +function updateProgressBar (prefix, suffix, bytesLoaded, bytesTotal) { + var loadingProgress = document.getElementById("loadingProgress"); + var progressBar = document.getElementById("progressBar"); + var progressText = document.getElementById("progressText"); + + if (LaFuDivContainer == null) + LaFuInsertStartScreen("loadingProgress"); + + var progress = 0.0; + if (prefix.startsWith("Downloading")) { + progress = 0.5 * bytesLoaded / bytesTotal; + } + else if (prefix.startsWith("Loading")) { + progress = 0.5 + 0.5 * bytesLoaded / bytesTotal; + } + else if (prefix.startsWith("Starting")) { + progress = 1; + } + if (progress > 1) + progress = 1; + if (progress < 0) + progress = 0; + + LaFuSetProgress(progress); + + if (loadingProgress && progressBar) { + if (progress == 1) + progressBar.style.transition = "width 0s"; + progressBar.style.width = (progress * loadingProgress.clientWidth).toString() + "px"; + } + + if (progressText) { + var progressString; + + if (suffix === null) { + progressString = prefix; + } else { + progressString = prefix + Math.floor(bytesLoaded) + suffix + " / " + Math.floor(bytesTotal) + suffix; + } + + if (jsilConfig.formatProgressText) + progressString = jsilConfig.formatProgressText(prefix, suffix, bytesLoaded, bytesTotal, progressString); + + progressText.textContent = progressString; + progressText.style.left = ((loadingProgress.clientWidth - progressText.clientWidth) / 2).toString() + "px"; + progressText.style.top = ((loadingProgress.clientHeight - progressText.clientHeight) * 0.75).toString() + "px"; + } + } + diff --git a/dis/VSTemplate/WebAsm/Scripts/mono_support.js b/dis/VSTemplate/WebAsm/Scripts/mono_support.js new file mode 100644 index 000000000..3e12a05ea --- /dev/null +++ b/dis/VSTemplate/WebAsm/Scripts/mono_support.js @@ -0,0 +1,48 @@ +var MonoSupport; +(function (MonoSupport) { + /** + * This class is used by https://github.com/mono/mono/blob/fa726d3ac7153d87ed187abd422faa4877f85bb5/sdks/wasm/dotnet_support.js#L88 to perform + * unmarshaled invocation of javascript from .NET code. + * */ + class jsCallDispatcher { + static registerScope(identifier, instance) { + jsCallDispatcher.registrations.set(identifier, instance); + } + static findJSFunction(identifier) { + if (!identifier) { + return jsCallDispatcher.dispatch; + } + else { + const { ns, methodName } = jsCallDispatcher.parseIdentifier(identifier); + var instance = jsCallDispatcher.registrations.get(ns); + if (instance) { + var boundMethod = instance[methodName].bind(instance); + var methodId = jsCallDispatcher.cacheMethod(boundMethod); + return () => methodId; + } + else { + throw `Unknown scope ${ns}`; + } + } + } + static dispatch(id, pParams, pRet) { + return jsCallDispatcher.methodMap[id](pParams, pRet); + } + static parseIdentifier(identifier) { + var parts = identifier.split(':'); + const ns = parts[0]; + const methodName = parts[1]; + return { ns, methodName }; + } + static cacheMethod(boundMethod) { + var methodId = Object.keys(jsCallDispatcher.methodMap).length; + jsCallDispatcher.methodMap[methodId] = boundMethod; + return methodId; + } + } + jsCallDispatcher.registrations = new Map(); + jsCallDispatcher.methodMap = {}; + MonoSupport.jsCallDispatcher = jsCallDispatcher; +})(MonoSupport || (MonoSupport = {})); +// Export the DotNet helper for WebAssembly.JSInterop.InvokeJSUnmarshalled +window.DotNet = MonoSupport; \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/WebAsm.cs b/dis/VSTemplate/WebAsm/WebAsm.cs new file mode 100644 index 000000000..44bbde302 --- /dev/null +++ b/dis/VSTemplate/WebAsm/WebAsm.cs @@ -0,0 +1,165 @@ +using Fusee.Base.Common; +using Fusee.Base.Core; +using Fusee.Base.Imp.WebAsm; +using Fusee.Engine.Core; +using Fusee.Engine.Imp.Graphics.WebAsm; +using Fusee.Math.Core; +using Fusee.Serialization; +using Fusee.Xene; +using SkiaSharp; +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; +using Path = Fusee.Base.Common.Path; + + +namespace $ext_safeprojectname$.WebAsm +{ + internal static class Program + { + public static void Main() + { + // This method takes care of everything + WebAsmProgram.Start(new Main()); + } + } + + public class Main : WebAsmBase + { + private RenderCanvasImp _canvasImp; + private Core.__PROJECTNAME__ _app; + + public override void Run() + { + base.Run(); + + // disable the debug output as the console output and debug output are the same for web + // this prevents that every message is printed twice! + Diagnostics.SetMinDebugOutputLoggingSeverityLevel(Diagnostics.SeverityLevel.NONE); + + // Inject Fusee.Engine.Base InjectMe dependencies + IO.IOImp = new Fusee.Base.Imp.WebAsm.IOImp(); + + + var fap = new Fusee.Base.Imp.WebAsm.AssetProvider(); + fap.RegisterTypeHandler( + new AssetHandler + { + ReturnedType = typeof(Font), + DecoderAsync = async (string id, object storage) => + { + if (Path.GetExtension(id).IndexOf("ttf", System.StringComparison.OrdinalIgnoreCase) >= 0) + { + var font = new Font + { + _fontImp = await Task.Factory.StartNew(() => new FontImp((Stream)storage)).ConfigureAwait(false) + }; + + return font; + } + + return null; + }, + Checker = (string id) => + { + return Path.GetExtension(id).IndexOf("ttf", System.StringComparison.OrdinalIgnoreCase) >= 0; + } + }); + + fap.RegisterTypeHandler( + new AssetHandler + { + ReturnedType = typeof(SceneContainer), + DecoderAsync = async (string id, object storage) => + { + if (Path.GetExtension(id).IndexOf("fus", System.StringComparison.OrdinalIgnoreCase) >= 0) + { + var storageStream = (Stream)storage; + return await Task.Factory.StartNew(() => Serializer.DeserializeSceneContainer((Stream)storage)).ConfigureAwait(false); + } + return null; + }, + Checker = (string id) => + { + return Path.GetExtension(id).IndexOf("fus", System.StringComparison.OrdinalIgnoreCase) >= 0; + } + }); + + // Image handler + fap.RegisterTypeHandler(new AssetHandler + { + ReturnedType = typeof(Base.Core.ImageData), + DecoderAsync = async (string id, object storage) => + { + var ext = Path.GetExtension(id).ToLower(); + switch (ext) + { + //case ".jpg": // not possible YET! + // case ".jpeg": + case ".png": + case ".bmp": + using (var bitmap = await Task.Factory.StartNew(() => SKBitmap.Decode((Stream)storage))) + { + var rotated = new SKBitmap(bitmap.Width, bitmap.Height, true); + + using (var surface = new SKCanvas(rotated)) + { + surface.Clear(); + surface.Scale(1, -1, 0, bitmap.Height / 2.0f); // this mirrors the image within its' x-axis + surface.DrawBitmap(bitmap, 0, 0); + } + + return new Base.Core.ImageData(rotated.Width, rotated.Height) + { + PixelData = rotated.Bytes + }; + } + } + return null; + }, + Checker = (string id) => + { + var ext = Path.GetExtension(id).ToLower(); + switch (ext) + { + case ".png": + case ".bmp": + return true; + } + return false; + } + }); + + AssetStorage.RegisterProvider(fap); + + _app = new Core.__PROJECTNAME__(); + + // Inject Fusee.Engine InjectMe dependencies (hard coded) + _canvasImp = new RenderCanvasImp(canvas, gl, canvasWidth, canvasHeight); + _app.CanvasImplementor = _canvasImp; + _app.ContextImplementor = new RenderContextImp(_app.CanvasImplementor); + Input.AddDriverImp(new RenderCanvasInputDriverImp(_app.CanvasImplementor)); + + // Start the app + _app.Run(); + } + + public override void Update(double elapsedMilliseconds) + { + if (_canvasImp != null) + _canvasImp.DeltaTime = (float)(elapsedMilliseconds / 1000.0); + } + + public override void Draw() + { + _canvasImp?.DoRender(); + } + + public override void Resize(int width, int height) + { + base.Resize(width, height); + _canvasImp.DoResize(width, height); + } + } +} diff --git a/dis/VSTemplate/WebAsm/WebAsm.csproj b/dis/VSTemplate/WebAsm/WebAsm.csproj new file mode 100644 index 000000000..ecff2d36a --- /dev/null +++ b/dis/VSTemplate/WebAsm/WebAsm.csproj @@ -0,0 +1,33 @@ + + + $ext_safeprojectname$.Desktop + $ext_safeprojectname$.Desktop + netstandard2.0 + PLATFORM_WebAsm + Full + + + + ..\bin\WebAsm + + + + + + + + + + + + + + + + + + + + + + diff --git a/dis/VSTemplate/WebAsm/WebAsm.vstemplate b/dis/VSTemplate/WebAsm/WebAsm.vstemplate new file mode 100644 index 000000000..c45fa08d7 --- /dev/null +++ b/dis/VSTemplate/WebAsm/WebAsm.vstemplate @@ -0,0 +1,38 @@ + + + FUSEE WebAsm Project + This is a template for a FUSEE WebAssembly project + CSharp + true + Core + true + Enabled + true + true + __TemplateIcon.ico + __PreviewImage.png + + + + + + browser.css + + FuseeAnim.gif + FuseeSpinning.gif + + + loading.js + mono_support.js + SkiaSharp.js + + canvaskit.js + canvaskit.wasm + FuseeLogo.ico + index.html + NuGet.config + server.py + WebAsm.cs + + + \ No newline at end of file diff --git a/dis/VSTemplate/WebAsm/__PreviewImage.png b/dis/VSTemplate/WebAsm/__PreviewImage.png new file mode 100644 index 000000000..a6d3d4f28 Binary files /dev/null and b/dis/VSTemplate/WebAsm/__PreviewImage.png differ diff --git a/dis/VSTemplate/WebAsm/__TemplateIcon.ico b/dis/VSTemplate/WebAsm/__TemplateIcon.ico new file mode 100644 index 000000000..2f649cf97 Binary files /dev/null and b/dis/VSTemplate/WebAsm/__TemplateIcon.ico differ diff --git a/dis/VSTemplate/WebAsm/canvaskit.js b/dis/VSTemplate/WebAsm/canvaskit.js new file mode 100644 index 000000000..2496a0fdb --- /dev/null +++ b/dis/VSTemplate/WebAsm/canvaskit.js @@ -0,0 +1,342 @@ + +var CanvasKitInit = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + return ( +function(CanvasKitInit) { + CanvasKitInit = CanvasKitInit || {}; + +var c,h;var l,n,p;var r;r||(r=typeof CanvasKitInit !== 'undefined' ? CanvasKitInit : {});(function(a){function b(a){return Math.round(Math.max(0,Math.min(a||0,255)))}a.Color=function(a,e,f,g){return b(255*g)<<24|b(a)<<16|b(e)<<8|b(f)<<0}})(r); +(function(a){a.onRuntimeInitialized=function(){a.SkPath.prototype.addPath=function(){if(1===arguments.length)this._addPath(arguments[0],1,0,0,0,1,0,0,0,1);else if(2===arguments.length)this._addPath(arguments[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);else if(10===arguments.length){var a=arguments;this._addPath(arguments[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9])}else return console.Zs("addPath expected to take 1, 2, or 10 args. Got "+arguments.length),null;return this};a.SkPath.prototype.arcTo= +function(a,d,e,f,g){this._arcTo(a,d,e,f,g);return this};a.SkPath.prototype.close=function(){this._close();return this};a.SkPath.prototype.conicTo=function(a,d,e,f,g){this._conicTo(a,d,e,f,g);return this};a.SkPath.prototype.cubicTo=function(a,d,e,f,g,k){this._cubicTo(a,d,e,f,g,k);return this};a.SkPath.prototype.lineTo=function(a,d){this._lineTo(a,d);return this};a.SkPath.prototype.moveTo=function(a,d){this._moveTo(a,d);return this};a.SkPath.prototype.op=function(a,d){return this._op(a,d)?this:null}; +a.SkPath.prototype.quadTo=function(a,d,e,f){this._quadTo(a,d,e,f);return this};a.SkPath.prototype.simplify=function(){return this._simplify()?this:null};a.SkPath.prototype.transform=function(){if(1===arguments.length){var a=arguments[0];this._transform(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8])}else if(9===arguments.length)a=arguments,this._transform(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);else return console.Zs("transform expected to take 1 or 9 arguments. Got "+arguments.length),null;return this}}; +a.getWebGLSurface=function(a){var b=document.getElementById(a);if(!b)throw"Canvas with id "+a+" was not found";return this._getWebGLSurface(a,b.width,b.height)};a.LTRBRect=function(a,d,e,f){return{Yv:a,$v:d,Zv:e,Xv:f}};a.MakeSkDashPathEffect=function(b,d){d||(d=0);if(!b.length||1===b.length%2)throw"Intervals array must have even length";b instanceof Float32Array||(b=Float32Array.from(b));var e=a._malloc(4*b.length);a.HEAPF32.set(b,e/4);return a._MakeSkDashPathEffect(e,b.length,d)}})(r); +var aa={},ba;for(ba in r)r.hasOwnProperty(ba)&&(aa[ba]=r[ba]);r.arguments=[];r.thisProgram="./this.program";r.quit=function(a,b){throw b;};r.preRun=[];r.postRun=[];var ca=!1,da=!1,ea=!1,fa=!1;ca="object"===typeof window;da="function"===typeof importScripts;ea="object"===typeof process&&"function"===typeof require&&!ca&&!da;fa=!ca&&!ea&&!da;var u=""; +if(ea){u=__dirname+"/";var ha,ia;r.read=function(a,b){ha||(ha=require("fs"));ia||(ia=require("path"));a=ia.normalize(a);a=ha.readFileSync(a);return b?a:a.toString()};r.readBinary=function(a){a=r.read(a,!0);a.buffer||(a=new Uint8Array(a));assert(a.buffer);return a};1>2]=0;for(b=e+d;a>0]=0;return e}a.subarray||a.slice?H.set(a,e):H.set(new Uint8Array(a),e);return e}var wa="undefined"!==typeof TextDecoder?new TextDecoder("utf8"):void 0; +function xa(a,b,d){var e=b+d;for(d=b;a[d]&&!(d>=e);)++d;if(16f?e+=String.fromCharCode(f):(f-=65536,e+=String.fromCharCode(55296|f>>10,56320|f&1023))}}else e+=String.fromCharCode(f)}return e}function E(a,b){return a?xa(H,a,b):""} +function ya(a,b,d,e){if(!(0=k){var m=a.charCodeAt(++g);k=65536+((k&1023)<<10)|m&1023}if(127>=k){if(d>=e)break;b[d++]=k}else{if(2047>=k){if(d+1>=e)break;b[d++]=192|k>>6}else{if(65535>=k){if(d+2>=e)break;b[d++]=224|k>>12}else{if(d+3>=e)break;b[d++]=240|k>>18;b[d++]=128|k>>12&63}b[d++]=128|k>>6&63}b[d++]=128|k&63}}b[d]=0;return d-f}function B(a,b,d){return ya(a,H,b,d)} +function za(a){for(var b=0,d=0;d=e&&(e=65536+((e&1023)<<10)|a.charCodeAt(++d)&1023);127>=e?++b:b=2047>=e?b+2:65535>=e?b+3:b+4}return b}var Aa="undefined"!==typeof TextDecoder?new TextDecoder("utf-16le"):void 0;function Ba(a){0Fa&&y("TOTAL_MEMORY should be larger than TOTAL_STACK, was "+Fa+"! (TOTAL_STACK=5242880)"); +r.buffer?buffer=r.buffer:("object"===typeof WebAssembly&&"function"===typeof WebAssembly.Memory?(pa=new WebAssembly.Memory({initial:Fa/65536}),buffer=pa.buffer):buffer=new ArrayBuffer(Fa),r.buffer=buffer);Ea();G[130032]=5763264;function Ga(a){for(;0>2]=a);return a}function fb(a,b){for(var d=0,e=a.length-1;0<=e;e--){var f=a[e];"."===f?a.splice(e,1):".."===f?(a.splice(e,1),d++):d&&(a.splice(e,1),d--)}if(b)for(;d;d--)a.unshift("..");return a}function gb(a){var b="/"===a.charAt(0),d="/"===a.substr(-1);(a=fb(a.split("/").filter(function(a){return!!a}),!b).join("/"))||b||(a=".");a&&d&&(a+="/");return(b?"/":"")+a} +function hb(a){var b=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);a=b[0];b=b[1];if(!a&&!b)return".";b&&(b=b.substr(0,b.length-1));return a+b}function ib(a){if("/"===a)return"/";var b=a.lastIndexOf("/");return-1===b?a:a.substr(b+1)} +function jb(){for(var a="",b=!1,d=arguments.length-1;-1<=d&&!b;d--){b=0<=d?arguments[d]:"/";if("string"!==typeof b)throw new TypeError("Arguments to path.resolve must be strings");if(!b)return"";a=b+"/"+a;b="/"===b.charAt(0)}a=fb(a.split("/").filter(function(a){return!!a}),!b).join("/");return(b?"/":"")+a||"."}var kb=[];function lb(a,b){kb[a]={input:[],output:[],yt:b};mb(a,nb)} +var nb={open:function(a){var b=kb[a.node.rdev];if(!b)throw new M(ob);a.tty=b;a.seekable=!1},close:function(a){a.tty.yt.flush(a.tty)},flush:function(a){a.tty.yt.flush(a.tty)},read:function(a,b,d,e){if(!a.tty||!a.tty.yt.Mu)throw new M(pb);for(var f=0,g=0;g=b||(b=Math.max(b,d*(1048576>d?2:1.125)|0),0!=d&&(b=Math.max(b,256)),d=a.Cs,a.Cs=new Uint8Array(b),0b)a.Cs.length=b;else for(;a.Cs.length=a.node.Ks)return 0;a=Math.min(a.node.Ks-f,e);if(8b)throw new M(Cb);return b},Cu:function(a, +b,d){O.Gu(a.node,b+d);a.node.Ks=Math.max(a.node.Ks,b+d)},St:function(a,b,d,e,f,g,k){if(32768!==(a.node.mode&61440))throw new M(ob);d=a.node.Cs;if(k&2||d.buffer!==b&&d.buffer!==b.buffer){if(0>>0)%Ib.length}function Pb(a){var b=Ob(a.parent.id,a.name);a.tv=Ib[b];Ib[b]=a}function Ab(a,b){var d;if(d=(d=Qb(a,"x"))?d:a.Fs.lookup?0:13)throw new M(d,a);for(d=Ib[Ob(a.id,b)];d;d=d.tv){var e=d.name;if(d.parent.id===a.id&&e===b)return d}return a.Fs.lookup(a,b)} +function xb(a,b,d,e){Rb||(Rb=function(a,b,d,e){a||(a=this);this.parent=a;this.jt=a.jt;this.Tt=null;this.id=Hb++;this.name=b;this.mode=d;this.Fs={};this.Es={};this.rdev=e},Rb.prototype={},Object.defineProperties(Rb.prototype,{read:{get:function(){return 365===(this.mode&365)},set:function(a){a?this.mode|=365:this.mode&=-366}},write:{get:function(){return 146===(this.mode&146)},set:function(a){a?this.mode|=146:this.mode&=-147}}}));a=new Rb(a,b,d,e);Pb(a);return a} +var Sb={r:0,rs:1052672,"r+":2,w:577,wx:705,xw:705,"w+":578,"wx+":706,"xw+":706,a:1089,ax:1217,xa:1217,"a+":1090,"ax+":1218,"xa+":1218};function Tb(a){var b=["r","w","rw"][a&3];a&512&&(b+="w");return b}function Qb(a,b){if(Jb)return 0;if(-1===b.indexOf("r")||a.mode&292){if(-1!==b.indexOf("w")&&!(a.mode&146)||-1!==b.indexOf("x")&&!(a.mode&73))return 13}else return 13;return 0}function Ub(a,b){try{return Ab(a,b),17}catch(d){}return Qb(a,"wx")} +function Vb(a){var b=4096;for(a=a||0;a<=b;a++)if(!Gb[a])return a;throw new M(24);}function Wb(a,b){Xb||(Xb=function(){},Xb.prototype={},Object.defineProperties(Xb.prototype,{object:{get:function(){return this.node},set:function(a){this.node=a}}}));var d=new Xb,e;for(e in a)d[e]=a[e];a=d;b=Vb(b);a.fd=b;return Gb[b]=a}var wb={open:function(a){a.Es=Fb[a.node.rdev].Es;a.Es.open&&a.Es.open(a)},qt:function(){throw new M(29);}};function mb(a,b){Fb[a]={Es:b}} +function Zb(a,b){var d="/"===b,e=!b;if(d&&Eb)throw new M(16);if(!d&&!e){var f=Lb(b,{Ju:!1});b=f.path;f=f.node;if(f.Tt)throw new M(16);if(16384!==(f.mode&61440))throw new M(20);}b={type:a,jw:{},Ru:b,sv:[]};a=a.jt(b);a.jt=b;b.root=a;d?Eb=a:f&&(f.Tt=b,f.jt&&f.jt.sv.push(b))}function $b(a,b,d){var e=Lb(a,{parent:!0}).node;a=ib(a);if(!a||"."===a||".."===a)throw new M(22);var f=Ub(e,a);if(f)throw new M(f);if(!e.Fs.Rt)throw new M(1);return e.Fs.Rt(e,a,b,d)}function ac(a){$b(a,16895,0)} +function bc(a,b,d){"undefined"===typeof d&&(d=b,b=438);$b(a,b|8192,d)}function cc(a,b){if(!jb(a))throw new M(2);var d=Lb(b,{parent:!0}).node;if(!d)throw new M(2);b=ib(b);var e=Ub(d,b);if(e)throw new M(e);if(!d.Fs.symlink)throw new M(1);d.Fs.symlink(d,b,a)}function Mb(a){a=Lb(a).node;if(!a)throw new M(2);if(!a.Fs.readlink)throw new M(22);return jb(Nb(a.parent),a.Fs.readlink(a))} +function dc(a,b,d,e){if(""===a)throw new M(2);if("string"===typeof b){var f=Sb[b];if("undefined"===typeof f)throw Error("Unknown file open mode: "+b);b=f}d=b&64?("undefined"===typeof d?438:d)&4095|32768:0;if("object"===typeof a)var g=a;else{a=gb(a);try{g=Lb(a,{ju:!(b&131072)}).node}catch(m){}}f=!1;if(b&64)if(g){if(b&128)throw new M(17);}else g=$b(a,d,0),f=!0;if(!g)throw new M(2);8192===(g.mode&61440)&&(b&=-513);if(b&65536&&16384!==(g.mode&61440))throw new M(20);if(!f&&(d=g?40960===(g.mode&61440)? +40:16384===(g.mode&61440)&&("r"!==Tb(b)||b&512)?21:Qb(g,Tb(b)):2))throw new M(d);if(b&512){d=g;var k;"string"===typeof d?k=Lb(d,{ju:!0}).node:k=d;if(!k.Fs.ft)throw new M(1);if(16384===(k.mode&61440))throw new M(21);if(32768!==(k.mode&61440))throw new M(22);if(d=Qb(k,"w"))throw new M(d);k.Fs.ft(k,{size:0,timestamp:Date.now()})}b&=-641;e=Wb({node:g,path:Nb(g),flags:b,seekable:!0,position:0,Es:g.Es,Mv:[],error:!1},e);e.Es.open&&e.Es.open(e);!r.logReadFiles||b&1||(ec||(ec={}),a in ec||(ec[a]=1,console.log("FS.trackingDelegate error on read file: "+ +a)));try{Kb.onOpenFile&&(g=0,1!==(b&2097155)&&(g|=1),0!==(b&2097155)&&(g|=2),Kb.onOpenFile(a,g))}catch(m){console.log("FS.trackingDelegate['onOpenFile']('"+a+"', flags) threw an exception: "+m.message)}return e}function fc(a,b,d){if(null===a.fd)throw new M(9);if(!a.seekable||!a.Es.qt)throw new M(29);if(0!=d&&1!=d&&2!=d)throw new M(22);a.position=a.Es.qt(a,b,d);a.Mv=[]} +function hc(a,b,d,e){var f=C;if(0>d||0>e)throw new M(22);if(null===a.fd)throw new M(9);if(1===(a.flags&2097155))throw new M(9);if(16384===(a.node.mode&61440))throw new M(21);if(!a.Es.read)throw new M(22);var g="undefined"!==typeof e;if(!g)e=a.position;else if(!a.seekable)throw new M(29);b=a.Es.read(a,f,b,d,e);g||(a.position+=b);return b} +function ic(){M||(M=function(a,b){this.node=b;this.Dv=function(a){this.Rs=a};this.Dv(a);this.message="FS error";this.stack&&Object.defineProperty(this,"stack",{value:Error().stack,writable:!0})},M.prototype=Error(),M.prototype.constructor=M,[2].forEach(function(a){yb[a]=new M(a);yb[a].stack=""}))}var jc;function kc(a,b){var d=0;a&&(d|=365);b&&(d|=146);return d} +function lc(a,b,d){a=gb("/dev/"+a);var e=kc(!!b,!!d);mc||(mc=64);var f=mc++<<8|0;mb(f,{open:function(a){a.seekable=!1},close:function(){d&&d.buffer&&d.buffer.length&&d(10)},read:function(a,d,e,f){for(var g=0,k=0;k>2]=e.dev;G[b+4>>2]=0;G[b+8>>2]=e.ino;G[b+12>>2]=e.mode;G[b+16>>2]=e.nlink;G[b+20>>2]=e.uid;G[b+24>>2]=e.gid;G[b+28>>2]=e.rdev;G[b+32>>2]=0;G[b+36>>2]=e.size;G[b+40>>2]=4096;G[b+44>>2]=e.blocks;G[b+48>>2]=e.atime.getTime()/1E3|0;G[b+52>>2]=0;G[b+56>>2]=e.mtime.getTime()/1E3|0;G[b+60>>2]=0;G[b+64>>2]=e.ctime.getTime()/1E3| +0;G[b+68>>2]=0;G[b+72>>2]=e.ino;return 0}var Q=0;function R(){Q+=4;return G[Q-4>>2]}function pc(){var a=Gb[R()];if(!a)throw new M(9);return a}var qc={};function rc(a){for(;a.length;){var b=a.pop();a.pop()(b)}}function sc(a){return this.fromWireType(K[a>>2])}var tc={},uc={},vc={};function wc(a){if(void 0===a)return"_unknown";a=a.replace(/[^a-zA-Z0-9_]/g,"$");var b=a.charCodeAt(0);return 48<=b&&57>=b?"_"+a:a} +function xc(a,b){a=wc(a);return(new Function("body","return function "+a+'() {\n "use strict"; return body.apply(this, arguments);\n};\n'))(b)}function yc(a){var b=Error,d=xc(a,function(b){this.name=a;this.message=b;b=Error(b).stack;void 0!==b&&(this.stack=this.toString()+"\n"+b.replace(/^Error(:[^\n]*)?\n/,""))});d.prototype=Object.create(b.prototype);d.prototype.constructor=d;d.prototype.toString=function(){return void 0===this.message?this.name:this.name+": "+this.message};return d} +var zc=void 0;function Ac(a){throw new zc(a);}function Bc(a,b,d){function e(b){b=d(b);b.length!==a.length&&Ac("Mismatched type converter count");for(var e=0;e>2)+e]);return d} +function fd(a){var b=Function;if(!(b instanceof Function))throw new TypeError("new_ called with constructor type "+typeof b+" which is not a function");var d=xc(b.name||"unknownFunctionName",function(){});d.prototype=b.prototype;d=new d;a=b.apply(d,a);return a instanceof Object?a:d} +function gd(a,b,d,e,f){var g=b.length;2>g&&U("argTypes array size mismatch! Must at least get return value and 'this' types!");var k=null!==b[1]&&null!==d,m=!1;for(d=1;d>1])};case 2:return function(a){return this.fromWireType((d?G:K)[a>>2])};default:throw new TypeError("Unknown integer type: "+a);}} +function kd(a,b){var d=uc[a];void 0===d&&U(b+" has unknown type "+bd(a));return d}function Sc(a){if(null===a)return"null";var b=typeof a;return"object"===b||"array"===b||"function"===b?a.toString():""+a}function ld(a,b){switch(b){case 2:return function(a){return this.fromWireType(L[a>>2])};case 3:return function(a){return this.fromWireType(Da[a>>3])};default:throw new TypeError("Unknown float type: "+a);}} +function md(a,b,d){switch(b){case 0:return d?function(a){return C[a]}:function(a){return H[a]};case 1:return d?function(a){return J[a>>1]}:function(a){return Ca[a>>1]};case 2:return d?function(a){return G[a>>2]}:function(a){return K[a>>2]};default:throw new TypeError("Unknown integer type: "+a);}}function nd(){v()}function od(){v("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking")} +function pd(a,b){l.As.au=a;l.As.bu=b;if(l.As.it)if(0==a)l.As.rt=function(){var a=Math.max(0,l.As.Hv+b-nd())|0;setTimeout(l.As.$t,a)},l.As.method="timeout";else if(1==a)l.As.rt=function(){l.requestAnimationFrame(l.As.$t)},l.As.method="rAF";else if(2==a){if("undefined"===typeof setImmediate){var d=[];addEventListener("message",function(a){if("setimmediate"===a.data||"setimmediate"===a.data.target)a.stopPropagation(),d.shift()()},!0);setImmediate=function(a){d.push(a);da?(void 0===r.setImmediates&&(r.setImmediates= +[]),r.setImmediates.push(a),postMessage({target:"setimmediate"})):postMessage("setimmediate","*")}}l.As.rt=function(){setImmediate(l.As.$t)};l.As.method="immediate"}} +function qd(a){var b=l.As.ot;r.noExitRuntime=!0;assert(!l.As.it,"emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.");l.As.it=a;l.As.ot=b;var d="undefined"!==typeof b?function(){r.dynCall_vi(a,b)}:function(){r.dynCall_v(a)};var e=l.As.ut;l.As.$t=function(){if(!A)if(0>g-6&63;g-=6;e+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[m]}2==g?(e+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(f&3)<<4],e+="=="):4==g&&(e+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(f& +15)<<2],e+="=");w.src="data:audio/x-"+b.substr(-3)+";base64,"+e;d(w)}};w.src=t;l.Bv(function(){d(w)},1E4)}else return e()}});var b=r.canvas;b&&(b.requestPointerLock=b.requestPointerLock||b.mozRequestPointerLock||b.webkitRequestPointerLock||b.msRequestPointerLock||function(){},b.exitPointerLock=document.exitPointerLock||document.mozExitPointerLock||document.webkitExitPointerLock||document.msExitPointerLock||function(){},b.exitPointerLock=b.exitPointerLock.bind(document),document.addEventListener("pointerlockchange", +a,!1),document.addEventListener("mozpointerlockchange",a,!1),document.addEventListener("webkitpointerlockchange",a,!1),document.addEventListener("mspointerlockchange",a,!1),r.elementPointerLock&&b.addEventListener("click",function(a){!l.ru&&r.canvas.requestPointerLock&&(r.canvas.requestPointerLock(),a.preventDefault())},!1))}},createContext:function(a,b,d,e){if(b&&r.Kt&&a==r.canvas)return r.Kt;var f;if(b){var g={antialias:!1,alpha:!1,Ou:1};if(e)for(var k in e)g[k]=e[k];if("undefined"!==typeof n&& +(f=n.createContext(a,g)))var m=n.getContext(f).tt}else m=a.getContext("2d");if(!m)return null;d&&(b||assert("undefined"===typeof p,"cannot set in module if GLctx is used, but we are a non-GL context that would replace it"),r.Kt=m,b&&n.Pu(f),r.uw=b,l.rv.forEach(function(a){a()}),l.pu());return m},Tv:function(){},Ku:!1,Pt:void 0,zt:void 0,requestFullscreen:function(a,b,d){function e(){l.Nt=!1;var a=f.parentNode;(document.fullscreenElement||document.mozFullScreenElement||document.msFullscreenElement|| +document.webkitFullscreenElement||document.webkitCurrentFullScreenElement)===a?(f.exitFullscreen=document.exitFullscreen||document.cancelFullScreen||document.mozCancelFullScreen||document.msExitFullscreen||document.webkitCancelFullScreen||function(){},f.exitFullscreen=f.exitFullscreen.bind(document),l.Pt&&f.requestPointerLock(),l.Nt=!0,l.zt?l.Ev():l.Gt(f)):(a.parentNode.insertBefore(f,a),a.parentNode.removeChild(a),l.zt?l.Fv():l.Gt(f));if(r.onFullScreen)r.onFullScreen(l.Nt);if(r.onFullscreen)r.onFullscreen(l.Nt)} +l.Pt=a;l.zt=b;l.Zu=d;"undefined"===typeof l.Pt&&(l.Pt=!0);"undefined"===typeof l.zt&&(l.zt=!1);"undefined"===typeof l.Zu&&(l.Zu=null);var f=r.canvas;l.Ku||(l.Ku=!0,document.addEventListener("fullscreenchange",e,!1),document.addEventListener("mozfullscreenchange",e,!1),document.addEventListener("webkitfullscreenchange",e,!1),document.addEventListener("MSFullscreenChange",e,!1));var g=document.createElement("div");f.parentNode.insertBefore(g,f);g.appendChild(f);g.requestFullscreen=g.requestFullscreen|| +g.mozRequestFullScreen||g.msRequestFullscreen||(g.webkitRequestFullscreen?function(){g.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT)}:null)||(g.webkitRequestFullScreen?function(){g.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT)}:null);d?g.requestFullscreen({vw:d}):g.requestFullscreen()},Xu:function(a,b,d){y("Browser.requestFullScreen() is deprecated. Please call Browser.requestFullscreen instead.");l.Xu=function(a,b,d){return l.requestFullscreen(a,b,d)};return l.requestFullscreen(a, +b,d)},xt:0,Hu:function(a){var b=Date.now();if(0===l.xt)l.xt=b+1E3/60;else for(;b+2>=l.xt;)l.xt+=1E3/60;setTimeout(a,Math.max(l.xt-b,0))},requestAnimationFrame:function(a){"undefined"===typeof window?l.Hu(a):(window.requestAnimationFrame||(window.requestAnimationFrame=window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.msRequestAnimationFrame||window.oRequestAnimationFrame||l.Hu),window.requestAnimationFrame(a))},ow:function(a){return function(){if(!A)return a.apply(null, +arguments)}},Bt:!0,Dt:[],kw:function(){l.Bt=!1},nw:function(){l.Bt=!0;if(0>2]:-1;a+=E(G[d+4*f>>2],0>g?void 0:g)}return a},createContext:function(a,b){return(a=a.getContext("webgl", +b)||a.getContext("experimental-webgl",b))&&n.xv(a,b)},xv:function(a,b){var d=va(8),e={handle:d,attributes:b,version:b.Ou,tt:a};a.canvas&&(a.canvas.$u=e);n.at[d]=e;("undefined"===typeof b.Fu||b.Fu)&&n.lv(e);return d},Pu:function(a){n.currentContext=n.at[a];r.Kt=p=n.currentContext&&n.currentContext.tt;return!(a&&!p)},getContext:function(a){return n.at[a]},Sv:function(a){n.currentContext===n.at[a]&&(n.currentContext=null);if("object"===typeof sd)for(var b=n.at[a].tt.canvas,d=0;da.version){var d=b.getExtension("ANGLE_instanced_arrays");d&&(b.vertexAttribDivisor=function(a,b){d.vertexAttribDivisorANGLE(a,b)},b.drawArraysInstanced=function(a,b,e,f){d.drawArraysInstancedANGLE(a,b,e,f)},b.drawElementsInstanced=function(a,b,e,f,g){d.drawElementsInstancedANGLE(a, +b,e,f,g)});var e=b.getExtension("OES_vertex_array_object");e&&(b.createVertexArray=function(){return e.createVertexArrayOES()},b.deleteVertexArray=function(a){e.deleteVertexArrayOES(a)},b.bindVertexArray=function(a){e.bindVertexArrayOES(a)},b.isVertexArray=function(a){return e.isVertexArrayOES(a)});var f=b.getExtension("WEBGL_draw_buffers");f&&(b.drawBuffers=function(a,b){f.drawBuffersWEBGL(a,b)})}b.Us=b.getExtension("EXT_disjoint_timer_query");var g="OES_texture_float OES_texture_half_float OES_standard_derivatives OES_vertex_array_object WEBGL_compressed_texture_s3tc WEBGL_depth_texture OES_element_index_uint EXT_texture_filter_anisotropic EXT_frag_depth WEBGL_draw_buffers ANGLE_instanced_arrays OES_texture_float_linear OES_texture_half_float_linear EXT_blend_minmax EXT_shader_texture_lod WEBGL_compressed_texture_pvrtc EXT_color_buffer_half_float WEBGL_color_buffer_float EXT_sRGB WEBGL_compressed_texture_etc1 EXT_disjoint_timer_query WEBGL_compressed_texture_etc WEBGL_compressed_texture_astc EXT_color_buffer_float WEBGL_compressed_texture_s3tc_srgb EXT_disjoint_timer_query_webgl2".split(" "); +(a=b.getSupportedExtensions())&&0>2]=k}} +function wd(a,b,d){if(b){var e=void 0;switch(a){case 36346:e=1;break;case 36344:"Integer"!==d&&"Integer64"!==d&&n.Ds(1280);return;case 36345:e=0;break;case 34466:var f=p.getParameter(34467);e=f?f.length:0}if(void 0===e)switch(f=p.getParameter(a),typeof f){case "number":e=f;break;case "boolean":e=f?1:0;break;case "string":n.Ds(1280);return;case "object":if(null===f)switch(a){case 34964:case 35725:case 34965:case 36006:case 36007:case 32873:case 34229:case 34068:e=0;break;default:n.Ds(1280);return}else{if(f instanceof +Float32Array||f instanceof Uint32Array||f instanceof Int32Array||f instanceof Array){for(a=0;a>2]=f[a];break;case "Float":L[b+4*a>>2]=f[a];break;case "Boolean":C[b+a>>0]=f[a]?1:0;break;default:throw"internal glGet error, bad type: "+d;}return}try{e=f.name|0}catch(g){n.Ds(1280);y("GL_INVALID_ENUM in glGet"+d+"v: Unknown object returned from WebGL getParameter("+a+")! (error: "+g+")");return}}break;default:n.Ds(1280);return}switch(d){case "Integer64":c= +[e>>>0,(h=e,1<=+Na(h)?0>>0:~~+Oa((h-+(~~h>>>0))/4294967296)>>>0:0)];G[b>>2]=c[0];G[b+4>>2]=c[1];break;case "Integer":G[b>>2]=e;break;case "Float":L[b>>2]=e;break;case "Boolean":C[b>>0]=e?1:0;break;default:throw"internal glGet error, bad type: "+d;}}else n.Ds(1281)}function xd(a){var b=za(a)+1,d=va(b);B(a,d,b);return d} +function yd(a,b,d,e){if(d)if(a=p.getUniform(n.Gs[a],n.Bs[b]),"number"==typeof a||"boolean"==typeof a)switch(e){case "Integer":G[d>>2]=a;break;case "Float":L[d>>2]=a;break;default:throw"internal emscriptenWebGLGetUniform() error, bad type: "+e;}else for(b=0;b>2]=a[b];break;case "Float":L[d+4*b>>2]=a[b];break;default:throw"internal emscriptenWebGLGetUniform() error, bad type: "+e;}else n.Ds(1281)} +function zd(a,b,d,e){if(d)if(a=p.getVertexAttrib(a,b),34975==b)G[d>>2]=a.name;else if("number"==typeof a||"boolean"==typeof a)switch(e){case "Integer":G[d>>2]=a;break;case "Float":L[d>>2]=a;break;case "FloatToInteger":G[d>>2]=Math.fround(a);break;default:throw"internal emscriptenWebGLGetVertexAttrib() error, bad type: "+e;}else for(b=0;b>2]=a[b];break;case "Float":L[d+4*b>>2]=a[b];break;case "FloatToInteger":G[d+4*b>>2]=Math.fround(a[b]);break;default:throw"internal emscriptenWebGLGetVertexAttrib() error, bad type: "+ +e;}else n.Ds(1281)}var Ad={6402:1,6406:1,6407:3,6408:4,6409:1,6410:2,35904:3,35906:4},Bd={5121:1,5123:2,5125:4,5126:4,32819:2,32820:2,33635:2,34042:4,36193:2};function Cd(a,b,d,e,f){if(b=Ad[b]*Bd[a]){var g=n.zu;d=f+e*(d*b+g-1&-g);switch(a){case 5121:return H.subarray(f,d);case 5126:return L.subarray(f>>2,d>>2);case 5125:case 34042:return K.subarray(f>>2,d>>2);case 5123:case 33635:case 32819:case 32820:case 36193:return Ca.subarray(f>>1,d>>1);default:n.Ds(1280)}}else n.Ds(1280)} +function Dd(a,b){Z(a,b||1);throw"longjmp";}var td=[],sd={},Ed=["default","low-power","high-performance"],Fd=[0,"undefined"!==typeof document?document:0,"undefined"!==typeof window?window:0];function Gd(a){try{if(!a)return window;"number"===typeof a&&(a=Fd[a]||E(a));return"#window"===a?window:"#document"===a?document:"#screen"===a?screen:"#canvas"===a?r.canvas:"string"===typeof a?document.getElementById(a):a}catch(b){return null}}var Hd={}; +function Id(a){if(0===a)return 0;a=E(a);if(!Hd.hasOwnProperty(a))return 0;Id.Zs&&X(Id.Zs);a=Hd[a];var b=za(a)+1,d=va(b);d&&ya(a,C,d,b);Id.Zs=d;return Id.Zs}function Jd(a){return Math.pow(2,a)}function Kd(a){return Math.log(a)/Math.LN2}function Ld(){Ld.Zs||(Ld.Zs=[]);Ld.Zs.push(D());return Ld.Zs.length-1}function Md(a){return 0===a%4&&(0!==a%100||0===a%400)}function Nd(a,b){for(var d=0,e=0;e<=b;d+=a[e++]);return d}var Od=[31,29,31,30,31,30,31,31,30,31,30,31],Pd=[31,28,31,30,31,30,31,31,30,31,30,31]; +function Qd(a,b){for(a=new Date(a.getTime());0e-a.getDate())b-=e-a.getDate()+1,a.setDate(1),11>d?a.setMonth(d+1):(a.setMonth(0),a.setFullYear(a.getFullYear()+1));else{a.setDate(a.getDate()+b);break}}return a} +function Rd(a,b,d,e){function f(a,b,d){for(a="number"===typeof a?a.toString():a||"";a.lengtha?-1:0=k(m(new Date(a.getFullYear(),0,4)),a)?0>=k(b,a)?a.getFullYear()+1:a.getFullYear():a.getFullYear()-1}var t=G[e+40>>2];e={Kv:G[e>>2],Jv:G[e+4>>2],cu:G[e+8>>2],st:G[e+12>>2],nt:G[e+16>>2],Os:G[e+20>>2],Yu:G[e+24>>2],du:G[e+28>>2],rw:G[e+32>>2],Iv:G[e+36>>2], +Lv:t?E(t):""};d=E(d);t={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S"};for(var w in t)d=d.replace(new RegExp(w,"g"),t[w]);var x="Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),I="January February March April May June July August September October November December".split(" ");t={"%a":function(a){return x[a.Yu].substring(0,3)},"%A":function(a){return x[a.Yu]},"%b":function(a){return I[a.nt].substring(0, +3)},"%B":function(a){return I[a.nt]},"%C":function(a){return g((a.Os+1900)/100|0,2)},"%d":function(a){return g(a.st,2)},"%e":function(a){return f(a.st,2," ")},"%g":function(a){return q(a).toString().substring(2)},"%G":function(a){return q(a)},"%H":function(a){return g(a.cu,2)},"%I":function(a){a=a.cu;0==a?a=12:12a.cu?"AM":"PM"},"%S":function(a){return g(a.Kv,2)},"%t":function(){return"\t"},"%u":function(a){return(new Date(a.Os+1900,a.nt+1,a.st,0,0,0,0)).getDay()||7},"%U":function(a){var b=new Date(a.Os+1900,0,1),d=0===b.getDay()?b:Qd(b,7-b.getDay());a=new Date(a.Os+1900,a.nt,a.st);return 0>k(d,a)?g(Math.ceil((31-d.getDate()+(Nd(Md(a.getFullYear())?Od:Pd,a.getMonth()-1)-31)+a.getDate())/7),2):0===k(d,b)?"01":"00"},"%V":function(a){var b=m(new Date(a.Os+1900,0,4)),d=m(new Date(a.Os+ +1901,0,4)),e=Qd(new Date(a.Os+1900,0,1),a.du);return 0>k(e,b)?"53":0>=k(d,e)?"01":g(Math.ceil((b.getFullYear()k(d,a)?g(Math.ceil((31-d.getDate()+(Nd(Md(a.getFullYear())?Od:Pd,a.getMonth()-1)-31)+a.getDate())/7),2):0===k(d,b)?"01": +"00"},"%y":function(a){return(a.Os+1900).toString().substring(2)},"%Y":function(a){return a.Os+1900},"%z":function(a){a=a.Iv;var b=0<=a;a=Math.abs(a)/60;return(b?"+":"-")+String("0000"+(a/60*100+a%60)).slice(-4)},"%Z":function(a){return a.Lv},"%%":function(){return"%"}};for(w in t)0<=d.indexOf(w)&&(d=d.replace(new RegExp(w,"g"),t[w](e)));w=sb(d,!1);if(w.length>b)return 0;C.set(w,a);return w.length-1}ic();Ib=Array(4096);Zb(O,"/");ac("/tmp");ac("/home");ac("/home/web_user"); +(function(){ac("/dev");mb(259,{read:function(){return 0},write:function(a,b,d,k){return k}});bc("/dev/null",259);lb(1280,tb);lb(1536,ub);bc("/dev/tty",1280);bc("/dev/tty1",1536);if("object"===typeof crypto&&"function"===typeof crypto.getRandomValues){var a=new Uint8Array(1);var b=function(){crypto.getRandomValues(a);return a[0]}}else if(ea)try{var d=require("crypto");b=function(){return d.randomBytes(1)[0]}}catch(e){b=function(){return 256*Math.random()|0}}else b=function(){v("random_device")};lc("random", +b);lc("urandom",b);ac("/dev/shm");ac("/dev/shm/tmp")})();ac("/proc");ac("/proc/self");ac("/proc/self/fd");Zb({jt:function(){var a=xb("/proc/self","fd",16895,73);a.Fs={lookup:function(a,d){var b=Gb[+d];if(!b)throw new M(9);a={parent:null,jt:{Ru:"fake"},Fs:{readlink:function(){return b.path}}};return a.parent=a}};return a}},"/proc/self/fd");zc=r.InternalError=yc("InternalError");for(var Sd=Array(256),Td=0;256>Td;++Td)Sd[Td]=String.fromCharCode(Td);Ec=Sd;Fc=r.BindingError=yc("BindingError"); +Lc.prototype.isAliasOf=function(a){if(!(this instanceof Lc&&a instanceof Lc))return!1;var b=this.zs.Ls.Hs,d=this.zs.Js,e=a.zs.Ls.Hs;for(a=a.zs.Js;b.$s;)d=b.Ft(d),b=b.$s;for(;e.$s;)a=e.Ft(a),e=e.$s;return b===e&&d===a};Lc.prototype.clone=function(){this.zs.Js||Hc(this);if(this.zs.Ct)return this.zs.count.value+=1,this;var a=Object.create(Object.getPrototypeOf(this),{zs:{value:Gc(this.zs)}});a.zs.count.value+=1;a.zs.vt=!1;return a}; +Lc.prototype["delete"]=function(){this.zs.Js||Hc(this);this.zs.vt&&!this.zs.Ct&&U("Object already scheduled for deletion");--this.zs.count.value;if(0===this.zs.count.value){var a=this.zs;a.Ss?a.Xs.Vs(a.Ss):a.Ls.Hs.Vs(a.Js)}this.zs.Ct||(this.zs.Ss=void 0,this.zs.Js=void 0)};Lc.prototype.isDeleted=function(){return!this.zs.Js}; +Lc.prototype.deleteLater=function(){this.zs.Js||Hc(this);this.zs.vt&&!this.zs.Ct&&U("Object already scheduled for deletion");Jc.push(this);1===Jc.length&&Ic&&Ic(Kc);this.zs.vt=!0;return this};V.prototype.iv=function(a){this.Wu&&(a=this.Wu(a));return a};V.prototype.Eu=function(a){this.Vs&&this.Vs(a)};V.prototype.argPackAdvance=8;V.prototype.readValueFromPointer=sc;V.prototype.deleteObject=function(a){if(null!==a)a["delete"]()}; +V.prototype.fromWireType=function(a){function b(){return this.Ot?Zc(this.Hs.wt,{Ls:this.uv,Js:d,Xs:this,Ss:a}):Zc(this.Hs.wt,{Ls:this,Js:a})}var d=this.iv(a);if(!d)return this.Eu(a),null;var e=Yc(this.Hs,d);if(void 0!==e){if(0===e.zs.count.value)return e.zs.Js=d,e.zs.Ss=a,e.clone();e=e.clone();this.Eu(a);return e}e=this.Hs.fv(d);e=Mc[e];if(!e)return b.call(this);e=this.Mt?e.bv:e.pointerType;var f=Wc(d,this.Hs,e.Hs);return null===f?b.call(this):this.Ot?Zc(e.Hs.wt,{Ls:e,Js:f,Xs:this,Ss:a}):Zc(e.Hs.wt, +{Ls:e,Js:f})};r.getInheritedInstanceCount=function(){return Object.keys(Xc).length};r.getLiveInheritedInstances=function(){var a=[],b;for(b in Xc)Xc.hasOwnProperty(b)&&a.push(Xc[b]);return a};r.flushPendingDeletes=Kc;r.setDelayFunction=function(a){Ic=a;Jc.length&&Ic&&Ic(Kc)};ad=r.UnboundTypeError=yc("UnboundTypeError");r.count_emval_handles=function(){for(var a=0,b=5;bUd;Ud++)ud.push(Array(Ud));function sb(a,b){var d=Array(za(a)+1);a=ya(a,d,0,d.length);b&&(d.length=a);return d} +var ke=r.asm({},{f:v,e:function(a){oa=a},c:function(){return oa},Md:function(a){var b=D();try{return Vd(a)}catch(d){F(b);if(d!==d+0&&"longjmp"!==d)throw d;Z(1,0)}},ua:function(a,b){var d=D();try{return Wd(a,b)}catch(e){F(d);if(e!==e+0&&"longjmp"!==e)throw e;Z(1,0)}},Pa:function(a,b,d){var e=D();try{return Xd(a,b,d)}catch(f){F(e);if(f!==f+0&&"longjmp"!==f)throw f;Z(1,0)}},Aa:function(a,b,d,e){var f=D();try{return Yd(a,b,d,e)}catch(g){F(f);if(g!==g+0&&"longjmp"!==g)throw g;Z(1,0)}},$a:function(a,b, +d,e,f){var g=D();try{return Zd(a,b,d,e,f)}catch(k){F(g);if(k!==k+0&&"longjmp"!==k)throw k;Z(1,0)}},wb:function(a){var b=D();try{$d(a)}catch(d){F(b);if(d!==d+0&&"longjmp"!==d)throw d;Z(1,0)}},Ha:function(a,b){var d=D();try{ae(a,b)}catch(e){F(d);if(e!==e+0&&"longjmp"!==e)throw e;Z(1,0)}},wa:function(a,b,d){var e=D();try{be(a,b,d)}catch(f){F(e);if(f!==f+0&&"longjmp"!==f)throw f;Z(1,0)}},Na:function(a,b,d,e){var f=D();try{ce(a,b,d,e)}catch(g){F(f);if(g!==g+0&&"longjmp"!==g)throw g;Z(1,0)}},Ba:function(a, +b,d,e,f){var g=D();try{de(a,b,d,e,f)}catch(k){F(g);if(k!==k+0&&"longjmp"!==k)throw k;Z(1,0)}},Wg:function(a,b,d,e,f,g){var k=D();try{ee(a,b,d,e,f,g)}catch(m){F(k);if(m!==m+0&&"longjmp"!==m)throw m;Z(1,0)}},Mg:function(a,b,d,e,f,g,k,m,q,t){var w=D();try{fe(a,b,d,e,f,g,k,m,q,t)}catch(x){F(w);if(x!==x+0&&"longjmp"!==x)throw x;Z(1,0)}},ta:function(a,b){return z[a](b)},sa:function(a,b){return z[a](b)},ra:function(a,b,d){return z[a](b,d)},qa:function(a,b,d,e){return z[a](b,d,e)},pa:function(a,b,d){return z[a](b, +d)},oa:function(a,b,d,e,f){return z[a](b,d,e,f)},na:function(a){return z[a]()},ma:function(a,b){return z[a](b)},la:function(a,b,d,e){return z[a](b,d,e)},ka:function(a,b,d){return z[a](b,d)},ja:function(a,b,d,e,f){return z[a](b,d,e,f)},ia:function(a,b,d){return z[a](b,d)},ha:function(a,b,d,e){return z[a](b,d,e)},ga:function(a,b,d,e,f){return z[a](b,d,e,f)},fa:function(a,b,d,e,f){return z[a](b,d,e,f)},ea:function(a,b,d,e,f,g){return z[a](b,d,e,f,g)},da:function(a,b,d,e,f,g){return z[a](b,d,e,f,g)}, +ca:function(a,b,d,e,f,g,k){return z[a](b,d,e,f,g,k)},ba:function(a,b,d,e,f,g,k){return z[a](b,d,e,f,g,k)},aa:function(a,b,d,e,f,g,k,m){return z[a](b,d,e,f,g,k,m)},$:function(a,b,d,e,f,g,k,m,q){return z[a](b,d,e,f,g,k,m,q)},_:function(a,b,d,e,f,g,k,m,q,t){return z[a](b,d,e,f,g,k,m,q,t)},Z:function(a,b,d,e,f,g,k,m,q,t,w){return z[a](b,d,e,f,g,k,m,q,t,w)},Jb:function(a,b,d,e,f,g){return z[a](b,d,e,f,g)},Ib:function(a,b,d,e,f){return z[a](b,d,e,f)},Hb:function(a,b,d,e){return z[a](b,d,e)},Gb:function(a, +b,d,e){return z[a](b,d,e)},Fb:function(a,b){return z[a](b)},Eb:function(a,b,d){return z[a](b,d)},Db:function(a,b,d,e,f,g,k,m,q,t,w){return z[a](b,d,e,f,g,k,m,q,t,w)},Y:function(a){z[a]()},X:function(a,b){z[a](b)},W:function(a,b,d){z[a](b,d)},V:function(a,b,d,e,f){z[a](b,d,e,f)},U:function(a,b,d){z[a](b,d)},T:function(a,b){z[a](b)},S:function(a,b,d){z[a](b,d)},R:function(a,b,d,e){z[a](b,d,e)},Q:function(a,b,d,e,f){z[a](b,d,e,f)},P:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},O:function(a,b,d,e,f,g,k){z[a](b, +d,e,f,g,k)},N:function(a,b,d,e,f,g,k,m){z[a](b,d,e,f,g,k,m)},M:function(a,b,d,e,f,g,k,m,q,t,w){z[a](b,d,e,f,g,k,m,q,t,w)},L:function(a,b,d,e,f){z[a](b,d,e,f)},K:function(a,b,d,e,f){z[a](b,d,e,f)},J:function(a,b,d){z[a](b,d)},I:function(a,b,d,e){z[a](b,d,e)},H:function(a,b,d,e){z[a](b,d,e)},G:function(a,b,d,e,f){z[a](b,d,e,f)},F:function(a,b,d,e,f){z[a](b,d,e,f)},E:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},D:function(a,b,d,e,f,g,k){z[a](b,d,e,f,g,k)},C:function(a,b,d,e,f,g,k,m){z[a](b,d,e,f,g,k,m)},B:function(a, +b,d,e,f,g,k,m,q){z[a](b,d,e,f,g,k,m,q)},A:function(a,b,d,e,f,g,k,m,q,t,w,x){z[a](b,d,e,f,g,k,m,q,t,w,x)},z:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},y:function(a,b,d,e,f,g,k){z[a](b,d,e,f,g,k)},x:function(a,b,d,e){z[a](b,d,e)},w:function(a,b,d,e,f){z[a](b,d,e,f)},v:function(a,b,d,e,f,g,k,m,q,t,w,x,I){z[a](b,d,e,f,g,k,m,q,t,w,x,I)},u:function(a,b,d,e,f,g,k){z[a](b,d,e,f,g,k)},t:function(a,b,d,e,f){z[a](b,d,e,f)},s:function(a,b,d,e,f,g,k){z[a](b,d,e,f,g,k)},r:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},q:function(a, +b,d,e,f,g,k){z[a](b,d,e,f,g,k)},p:function(a,b,d,e,f,g,k,m,q,t){z[a](b,d,e,f,g,k,m,q,t)},o:function(a,b,d,e,f,g,k){z[a](b,d,e,f,g,k)},n:function(a,b,d,e,f,g,k,m){z[a](b,d,e,f,g,k,m)},m:function(a,b,d,e,f,g,k,m,q){z[a](b,d,e,f,g,k,m,q)},l:function(a,b,d,e,f,g,k,m,q,t){z[a](b,d,e,f,g,k,m,q,t)},k:function(a,b,d,e,f,g,k,m,q,t,w){z[a](b,d,e,f,g,k,m,q,t,w)},j:function(a,b,d,e,f,g,k,m,q,t,w,x){z[a](b,d,e,f,g,k,m,q,t,w,x)},i:function(a,b,d,e,f,g,k,m,q,t,w,x,I){z[a](b,d,e,f,g,k,m,q,t,w,x,I)},h:function(a, +b,d,e,f,g,k,m,q,t,w,x,I,N,ta,Yb){z[a](b,d,e,f,g,k,m,q,t,w,x,I,N,ta,Yb)},Cb:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},Bb:function(a,b,d,e,f){z[a](b,d,e,f)},Ab:function(a,b,d,e){z[a](b,d,e)},zb:function(a,b,d,e,f,g){z[a](b,d,e,f,g)},yb:function(a,b,d){z[a](b,d)},xb:function(a,b,d){z[a](b,d)},ya:function(a){return va(a)},vb:function(){A=!0;throw"Pure virtual function called!";},xa:function(a){"uncaught_exception"in ge?ge.Bu++:ge.Bu=1;throw a;},ub:function(){return!!ge.Bu},La:function(){},tb:function(){eb(1); +return-1},_a:eb,sb:function(a,b){Q=b;try{var d=pc();R();var e=R(),f=R(),g=R();fc(d,e,g);G[f>>2]=d.position;d.lu&&0===e&&0===g&&(d.lu=null);return 0}catch(k){return"undefined"!==typeof P&&k instanceof M||v(k),-k.Rs}},rb:function(a,b){Q=b;try{var d=pc(),e=R();a:{var f=R();for(b=a=0;b>2],k=hc(d,G[e+8*b>>2],g,void 0);if(0>k){var m=-1;break a}a+=k;if(k>2],m=G[e+(8*b+4)>>2],q=void 0,t=C;if(0>m||0>q)throw new M(22);if(null===g.fd)throw new M(9);if(0===(g.flags&2097155))throw new M(9);if(16384===(g.node.mode&61440))throw new M(21);if(!g.Es.write)throw new M(22);g.flags&1024&&fc(g,0,2);var w="undefined"!==typeof q;if(!w)q=g.position;else if(!g.seekable)throw new M(29);var x=g.Es.write(g,t,k,m,q,void 0);w||(g.position+=x);try{if(g.path&&Kb.onWriteToFile)Kb.onWriteToFile(g.path)}catch(ta){console.log("FS.trackingDelegate['onWriteToFile']('"+ +g.path+"') threw an exception: "+ta.message)}var I=x;if(0>I){var N=-1;break a}a+=I}N=a}return N}catch(ta){return"undefined"!==typeof P&&ta instanceof M||v(ta),-ta.Rs}},qb:function(a,b){Q=b;try{var d=pc(),e=R(),f=R();R();var g=R();R();return hc(d,e,f,g)}catch(k){return"undefined"!==typeof P&&k instanceof M||v(k),-k.Rs}},pb:function(a,b){Q=b;try{var d=R(),e=R(),f=R(),g=R(),k=R(),m=R();m<<=12;a=!1;if(-1===k){var q=he(16384,e);if(!q)return-Db;ie(q,0,e);a=!0}else{var t=Gb[k];if(!t)return-9;b=H;if(1=== +(t.flags&2097155))throw new M(13);if(!t.Es.St)throw new M(19);var w=t.Es.St(t,b,d,e,m,f,g);q=w.Js;a=w.eu}nc[q]={qv:q,pv:e,eu:a,fd:k,flags:g};return q}catch(x){return"undefined"!==typeof P&&x instanceof M||v(x),-x.Rs}},ob:function(a,b){Q=b;try{var d=E(R()),e=R();return oc(d,e)}catch(f){return"undefined"!==typeof P&&f instanceof M||v(f),-f.Rs}},nb:function(a,b){Q=b;try{var d=pc(),e=R();return oc(d.path,e)}catch(f){return"undefined"!==typeof P&&f instanceof M||v(f),-f.Rs}},Ia:function(a,b){Q=b;try{var d= +pc();switch(R()){case 0:var e=R();return 0>e?-Cb:dc(d.path,d.flags,0,e).fd;case 1:case 2:return 0;case 3:return d.flags;case 4:return e=R(),d.flags|=e,0;case 12:return e=R(),J[e+0>>1]=2,0;case 13:case 14:return 0;case 16:case 8:return-Cb;case 9:return eb(Cb),-1;default:return-Cb}}catch(f){return"undefined"!==typeof P&&f instanceof M||v(f),-f.Rs}},mb:function(a,b){Q=b;try{var d=E(R()),e=R(),f=R();return dc(d,e,f).fd}catch(g){return"undefined"!==typeof P&&g instanceof M||v(g),-g.Rs}},Ya:function(a, +b){Q=b;try{var d=pc(),e=R();switch(e){case 21509:case 21505:return d.tty?0:-25;case 21510:case 21511:case 21512:case 21506:case 21507:case 21508:return d.tty?0:-25;case 21519:if(!d.tty)return-25;var f=R();return G[f>>2]=0;case 21520:return d.tty?-Cb:-25;case 21531:a=f=R();if(!d.Es.ov)throw new M(25);return d.Es.ov(d,e,a);case 21523:return d.tty?0:-25;case 21524:return d.tty?0:-25;default:v("bad ioctl syscall "+e)}}catch(g){return"undefined"!==typeof P&&g instanceof M||v(g),-g.Rs}},Xa:function(a,b){Q= +b;try{var d=pc();if(null===d.fd)throw new M(9);d.lu&&(d.lu=null);try{d.Es.close&&d.Es.close(d)}catch(e){throw e;}finally{Gb[d.fd]=null}d.fd=null;return 0}catch(e){return"undefined"!==typeof P&&e instanceof M||v(e),-e.Rs}},gh:function(a,b){Q=b;try{var d=R(),e=R(),f=nc[d];if(!f)return 0;if(e===f.pv){var g=Gb[f.fd],k=f.flags,m=new Uint8Array(H.subarray(d,d+e));g&&g.Es.Yt&&g.Es.Yt(g,m,0,e,k);nc[d]=null;f.eu&&X(f.qv)}return 0}catch(q){return"undefined"!==typeof P&&q instanceof M||v(q),-q.Rs}},Ka:function(){}, +fh:function(a){var b=qc[a];delete qc[a];var d=b.elements,e=d.length,f=d.map(function(a){return a.ou}).concat(d.map(function(a){return a.xu})),g=b.Et,k=b.Vs;Bc([a],f,function(a){d.forEach(function(b,d){var f=a[d],g=b.mu,k=b.nu,m=a[d+e],q=b.wu,t=b.yu;b.read=function(a){return f.fromWireType(g(k,a))};b.write=function(a,b){var d=[];q(t,a,m.toWireType(d,b));rc(d)}});return[{name:b.name,fromWireType:function(a){for(var b=Array(e),f=0;f>g])},Qs:null})},Ga:function(a,b,d,e,f,g,k,m,q,t,w,x,I){w=T(w);g=W(f,g);m&&(m=W(k,m));t&&(t=W(q,t));I=W(x,I);var N=wc(w);Oc(N,function(){dd("Cannot construct "+w+" due to unbound types",[e])});Bc([a,b,d],e?[e]:[],function(b){b=b[0];if(e){var d=b.Hs;var f=d.wt}else f=Lc.prototype; +b=xc(N,function(){if(Object.getPrototypeOf(this)!==k)throw new Fc("Use 'new' to construct "+w);if(void 0===q.pt)throw new Fc(w+" has no accessible constructor");var a=q.pt[arguments.length];if(void 0===a)throw new Fc("Tried to invoke ctor of "+w+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(q.pt).toString()+") parameters instead!");return a.apply(this,arguments)});var k=Object.create(f,{constructor:{value:b}});b.prototype=k;var q=new Pc(w,b,k,I,d,g,m,t);d=new V(w, +q,!0,!1,!1);f=new V(w+"*",q,!1,!1,!1);var x=new V(w+" const*",q,!1,!0,!1);Mc[a]={pointerType:f,bv:x};$c(N,b);return[d,f,x]})},Oa:function(a,b,d,e,f,g){var k=ed(b,d);f=W(e,f);Bc([],[a],function(a){a=a[0];var d="constructor "+a.name;void 0===a.Hs.pt&&(a.Hs.pt=[]);if(void 0!==a.Hs.pt[b-1])throw new Fc("Cannot register multiple constructors with identical number of parameters ("+(b-1)+") for class '"+a.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!"); +a.Hs.pt[b-1]=function(){dd("Cannot construct "+a.name+" due to unbound types",k)};Bc([],k,function(e){a.Hs.pt[b-1]=function(){arguments.length!==b-1&&U(d+" called with "+arguments.length+" arguments, expected "+(b-1));var a=[],k=Array(b);k[0]=g;for(var m=1;m>>m}}var q=-1!=b.indexOf("unsigned");S(a,{name:b,fromWireType:g,toWireType:function(a,d){if("number"!==typeof d&&"boolean"!==typeof d)throw new TypeError('Cannot convert "'+Sc(d)+'" to '+this.name);if(df)throw new TypeError('Passing a number "'+Sc(d)+'" from JS side to C/C++ side to an argument of type "'+b+'", which is outside the valid range ['+e+", "+f+"]!");return q?d>>>0:d|0},argPackAdvance:8,readValueFromPointer:md(b,k,0!==e),Qs:null})}, +va:function(a,b,d){function e(a){a>>=2;var b=K;return new f(b.buffer,b[a+1],b[a])}var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array][b];d=T(d);S(a,{name:d,fromWireType:e,argPackAdvance:8,readValueFromPointer:e},{kv:!0})},Ja:function(a,b,d,e,f,g,k,m,q,t,w,x){d=T(d);g=W(f,g);m=W(k,m);t=W(q,t);x=W(w,x);Bc([a],[b],function(a){a=a[0];return[new V(d,a.Hs,!1,!1,!0,a,e,g,m,t,x)]})},ib:function(a,b){b=T(b);var d="std::string"===b;S(a,{name:b,fromWireType:function(a){var b= +K[a>>2];if(d){var e=H[a+4+b],k=0;0!=e&&(k=e,H[a+4+b]=0);var m=a+4;for(e=0;e<=b;++e){var q=a+4+e;if(0==H[q]){m=E(m);if(void 0===t)var t=m;else t+=String.fromCharCode(0),t+=m;m=q+1}}0!=k&&(H[a+4+b]=k)}else{t=Array(b);for(e=0;e>2]=f;if(d&&e)B(b,m+4,f+1);else if(e)for(e=0;e>2],g=Array(d),t=a+4>>f,w=0;w>2]=k;for(var w=t+4>>f,x=0;x>2]=a/1E3|0;G[b+4>>2]=a%1E3*1E6|0;return 0},Ta:function(){return od.apply(null,arguments)},Sa:od,Ra:function(){return od.apply(null,arguments)},Vg:function(){return 0},Ug:function(a){return je(a)},Tg:function(a,b){if(62E3!=a)return 0;if(rd[b])return rd[b];switch(b){case 12371:a=ua(sb("Emscripten"));break;case 12372:a=ua(sb("1.4 Emscripten EGL"));break;case 12373:a=ua(sb(""));break; +case 12429:a=ua(sb("OpenGL_ES"));break;default:return 0}return rd[b]=a},Sg:function(){return Fa},Rg:function(a){p.activeTexture(a)},Qg:function(a,b){p.attachShader(n.Gs[a],n.Is[b])},Pg:function(a,b){p.Us.beginQueryEXT(a,n.Ys[b])},Og:function(a,b,d){p.bindAttribLocation(n.Gs[a],b,E(d))},Ng:function(a,b){p.bindBuffer(a,n.gt[b])},Lg:function(a,b){p.bindFramebuffer(a,n.ht[b])},Kg:function(a,b){p.bindRenderbuffer(a,n.Ws[b])},Jg:function(a,b){p.bindTexture(a,n.Ts[b])},Ig:function(a){p.bindVertexArray(n.Ht[a])}, +Hg:function(a,b,d,e){p.blendColor(a,b,d,e)},Gg:function(a){p.blendEquation(a)},Fg:function(a,b){p.blendEquationSeparate(a,b)},Eg:function(a,b){p.blendFunc(a,b)},Dg:function(a,b,d,e){p.blendFuncSeparate(a,b,d,e)},Cg:function(a,b,d,e){p.bufferData(a,d?H.subarray(d,d+b):b,e)},Bg:function(a,b,d,e){p.bufferSubData(a,b,H.subarray(e,e+d))},Ag:function(a){return p.checkFramebufferStatus(a)},zg:function(a){p.clear(a)},yg:function(a,b,d,e){p.clearColor(a,b,d,e)},xg:function(a){p.clearDepth(a)},wg:function(a){p.clearStencil(a)}, +vg:function(a,b,d,e){p.colorMask(!!a,!!b,!!d,!!e)},ug:function(a){p.compileShader(n.Is[a])},tg:function(a,b,d,e,f,g,k,m){p.compressedTexImage2D(a,b,d,e,f,g,m?H.subarray(m,m+k):null)},sg:function(a,b,d,e,f,g,k,m,q){p.compressedTexSubImage2D(a,b,d,e,f,g,k,q?H.subarray(q,q+m):null)},rg:function(a,b,d,e,f,g,k,m){p.copyTexImage2D(a,b,d,e,f,g,k,m)},qg:function(a,b,d,e,f,g,k,m){p.copyTexSubImage2D(a,b,d,e,f,g,k,m)},pg:function(){var a=n.lt(n.Gs),b=p.createProgram();b.name=a;n.Gs[a]=b;return a},og:function(a){var b= +n.lt(n.Is);n.Is[b]=p.createShader(a);return b},ng:function(a){p.cullFace(a)},mg:function(a,b){for(var d=0;d>2],f=n.gt[e];f&&(p.deleteBuffer(f),f.name=0,n.gt[e]=null,e==n.gu&&(n.gu=0),e==n.hu&&(n.hu=0))}},lg:function(a,b){for(var d=0;d>2],f=n.ht[e];f&&(p.deleteFramebuffer(f),f.name=0,n.ht[e]=null)}},kg:function(a){if(a){var b=n.Gs[a];b?(p.deleteProgram(b),b.name=0,n.Gs[a]=null,n.kt[a]=null):n.Ds(1281)}},jg:function(a,b){for(var d=0;d> +2],f=n.Ys[e];f&&(p.Us.deleteQueryEXT(f),n.Ys[e]=null)}},ig:function(a,b){for(var d=0;d>2],f=n.Ws[e];f&&(p.deleteRenderbuffer(f),f.name=0,n.Ws[e]=null)}},hg:function(a){if(a){var b=n.Is[a];b?(p.deleteShader(b),n.Is[a]=null):n.Ds(1281)}},gg:function(a,b){for(var d=0;d>2],f=n.Ts[e];f&&(p.deleteTexture(f),f.name=0,n.Ts[e]=null)}},fg:function(a,b){for(var d=0;d>2];p.deleteVertexArray(n.Ht[e]);n.Ht[e]=null}},eg:function(a){p.depthFunc(a)}, +dg:function(a){p.depthMask(!!a)},cg:function(a,b){p.depthRange(a,b)},bg:function(a,b){p.detachShader(n.Gs[a],n.Is[b])},ag:function(a){p.disable(a)},$f:function(a){p.disableVertexAttribArray(a)},_f:function(a,b,d){p.drawArrays(a,b,d)},Zf:function(a,b,d,e){p.drawArraysInstanced(a,b,d,e)},Yf:function(a,b){for(var d=ud[a],e=0;e>2];p.drawBuffers(d)},Xf:function(a,b,d,e){p.drawElements(a,b,d,e)},Wf:function(a,b,d,e,f){p.drawElementsInstanced(a,b,d,e,f)},Vf:function(a){p.enable(a)},Uf:function(a){p.enableVertexAttribArray(a)}, +Tf:function(a){p.Us.endQueryEXT(a)},Sf:function(){p.finish()},Rf:function(){p.flush()},Qf:function(a,b,d,e){p.framebufferRenderbuffer(a,b,d,n.Ws[e])},Pf:function(a,b,d,e,f){p.framebufferTexture2D(a,b,d,n.Ts[e],f)},Of:function(a){p.frontFace(a)},Nf:function(a,b){vd(a,b,"createBuffer",n.gt)},Mf:function(a,b){vd(a,b,"createFramebuffer",n.ht)},Lf:function(a,b){for(var d=0;d>2]=0;break}var f=n.lt(n.Ys);e.name=f;n.Ys[f]=e;G[b+4*d>> +2]=f}},Kf:function(a,b){vd(a,b,"createRenderbuffer",n.Ws)},Jf:function(a,b){vd(a,b,"createTexture",n.Ts)},If:function(a,b){vd(a,b,"createVertexArray",n.Ht)},Hf:function(a){p.generateMipmap(a)},Gf:function(a,b,d,e,f,g,k){a=n.Gs[a];if(a=p.getActiveAttrib(a,b))0>2]=d)):e&&(G[e>>2]=0),f&&(G[f>>2]=a.size),g&&(G[g>>2]=a.type)},Ff:function(a,b,d,e,f,g,k){a=n.Gs[a];if(a=p.getActiveUniform(a,b))0>2]=d)):e&&(G[e>>2]=0),f&&(G[f>>2]=a.size),g&&(G[g>> +2]=a.type)},Ef:function(a,b,d,e){a=p.getAttachedShaders(n.Gs[a]);var f=a.length;f>b&&(f=b);G[d>>2]=f;for(b=0;b>2]=n.Is.indexOf(a[b])},Df:function(a,b){return p.getAttribLocation(n.Gs[a],E(b))},Cf:function(a,b){wd(a,b,"Boolean")},Bf:function(a,b,d){d?G[d>>2]=p.getBufferParameter(a,b):n.Ds(1281)},Af:function(){if(n.mt){var a=n.mt;n.mt=0;return a}return p.getError()},zf:function(a,b){wd(a,b,"Float")},yf:function(a,b,d,e){a=p.getFramebufferAttachmentParameter(a,b,d);if(a instanceof WebGLRenderbuffer|| +a instanceof WebGLTexture)a=a.name|0;G[e>>2]=a},xf:function(a,b){wd(a,b,"Integer")},wf:function(a,b,d,e){a=p.getProgramInfoLog(n.Gs[a]);null===a&&(a="(unknown error)");0>2]=b)):d&&(G[d>>2]=0)},vf:function(a,b,d){if(d)if(a>=n.fu)n.Ds(1281);else{var e=n.kt[a];if(e)if(35716==b)a=p.getProgramInfoLog(n.Gs[a]),null===a&&(a="(unknown error)"),G[d>>2]=a.length+1;else if(35719==b)G[d>>2]=e.Qt;else if(35722==b){if(-1==e.ct){a=n.Gs[a];var f=p.getProgramParameter(a,35721);for(b=e.ct= +0;b>2]=e.ct}else if(35381==b){if(-1==e.dt)for(a=n.Gs[a],f=p.getProgramParameter(a,35382),b=e.dt=0;b>2]=e.dt}else G[d>>2]=p.getProgramParameter(n.Gs[a],b);else n.Ds(1282)}else n.Ds(1281)},uf:function(a,b,d){if(d){a=p.Us.getQueryObjectEXT(n.Ys[a],b);var e;"boolean"==typeof a?e=a?1:0:e=a;c=[e>>>0,(h=e,1<=+Na(h)?0>>0:~~+Oa((h- ++(~~h>>>0))/4294967296)>>>0:0)];G[d>>2]=c[0];G[d+4>>2]=c[1]}else n.Ds(1281)},tf:function(a,b,d){if(d){a=p.Us.getQueryObjectEXT(n.Ys[a],b);var e;"boolean"==typeof a?e=a?1:0:e=a;G[d>>2]=e}else n.Ds(1281)},sf:function(a,b,d){if(d){a=p.Us.getQueryObjectEXT(n.Ys[a],b);var e;"boolean"==typeof a?e=a?1:0:e=a;c=[e>>>0,(h=e,1<=+Na(h)?0>>0:~~+Oa((h-+(~~h>>>0))/4294967296)>>>0:0)];G[d>>2]=c[0];G[d+4>>2]=c[1]}else n.Ds(1281)},rf:function(a,b,d){if(d){a=p.Us.getQueryObjectEXT(n.Ys[a], +b);var e;"boolean"==typeof a?e=a?1:0:e=a;G[d>>2]=e}else n.Ds(1281)},qf:function(a,b,d){d?G[d>>2]=p.Us.getQueryEXT(a,b):n.Ds(1281)},pf:function(a,b,d){d?G[d>>2]=p.getRenderbufferParameter(a,b):n.Ds(1281)},of:function(a,b,d,e){a=p.getShaderInfoLog(n.Is[a]);null===a&&(a="(unknown error)");0>2]=b)):d&&(G[d>>2]=0)},nf:function(a,b,d,e){a=p.getShaderPrecisionFormat(a,b);G[d>>2]=a.rangeMin;G[d+4>>2]=a.rangeMax;G[e>>2]=a.precision},mf:function(a,b,d,e){if(a=p.getShaderSource(n.Is[a]))0< +b&&e?(b=B(a,e,b),d&&(G[d>>2]=b)):d&&(G[d>>2]=0)},lf:function(a,b,d){d?35716==b?(a=p.getShaderInfoLog(n.Is[a]),null===a&&(a="(unknown error)"),G[d>>2]=a.length+1):35720==b?(a=p.getShaderSource(n.Is[a]),G[d>>2]=null===a||0==a.length?0:a.length+1):G[d>>2]=p.getShaderParameter(n.Is[a],b):n.Ds(1281)},kf:function(a){if(n.At[a])return n.At[a];switch(a){case 7939:var b=p.getSupportedExtensions();for(var d=[],e=0;e>2]=p.getTexParameter(a,b):n.Ds(1281)},hf:function(a,b,d){d?G[d>>2]=p.getTexParameter(a,b):n.Ds(1281)},gf:function(a, +b){b=E(b);var d=0;if("]"==b[b.length-1]){var e=b.lastIndexOf("[");d="]"!=b[e+1]?parseInt(b.slice(e+1)):0;b=b.slice(0,e)}return(a=n.kt[a]&&n.kt[a].Bs[b])&&0<=d&&d>2]=p.getVertexAttribOffset(a,b):n.Ds(1281)},cf:function(a,b,d){zd(a,b,d,"Float")},bf:function(a,b,d){zd(a,b,d,"FloatToInteger")},af:function(a,b){p.hint(a,b)},$e:function(a){return(a=n.gt[a])?p.isBuffer(a):0},_e:function(a){return p.isEnabled(a)}, +Ze:function(a){return(a=n.ht[a])?p.isFramebuffer(a):0},Ye:function(a){return(a=n.Gs[a])?p.isProgram(a):0},Xe:function(a){return(a=n.Ys[a])?p.Us.isQueryEXT(a):0},We:function(a){return(a=n.Ws[a])?p.isRenderbuffer(a):0},Ve:function(a){return(a=n.Is[a])?p.isShader(a):0},Ue:function(a){return(a=n.Ts[a])?p.isTexture(a):0},Te:function(a){return(a=n.Ht[a])?p.isVertexArray(a):0},Se:function(a){p.lineWidth(a)},Re:function(a){p.linkProgram(n.Gs[a]);n.Uu(a)},Qe:function(a,b){3317==a&&(n.zu=b);p.pixelStorei(a, +b)},Pe:function(a,b){p.polygonOffset(a,b)},Oe:function(a,b){p.Us.queryCounterEXT(n.Ys[a],b)},Ne:function(a,b,d,e,f,g,k){(k=Cd(g,f,d,e,k))?p.readPixels(a,b,d,e,f,g,k):n.Ds(1280)},Me:function(){},Le:function(a,b,d,e){p.renderbufferStorage(a,b,d,e)},Ke:function(a,b){p.sampleCoverage(a,!!b)},Je:function(a,b,d,e){p.scissor(a,b,d,e)},Ie:function(){n.Ds(1280)},He:function(a,b,d,e){b=n.Lu(a,b,d,e);p.shaderSource(n.Is[a],b)},Ge:function(a,b,d){p.stencilFunc(a,b,d)},Fe:function(a,b,d,e){p.stencilFuncSeparate(a, +b,d,e)},Ee:function(a){p.stencilMask(a)},De:function(a,b){p.stencilMaskSeparate(a,b)},Ce:function(a,b,d){p.stencilOp(a,b,d)},Be:function(a,b,d,e){p.stencilOpSeparate(a,b,d,e)},Ae:function(a,b,d,e,f,g,k,m,q){p.texImage2D(a,b,d,e,f,g,k,m,q?Cd(m,k,e,f,q):null)},ze:function(a,b,d){p.texParameterf(a,b,d)},ye:function(a,b,d){p.texParameterf(a,b,L[d>>2])},xe:function(a,b,d){p.texParameteri(a,b,d)},we:function(a,b,d){p.texParameteri(a,b,G[d>>2])},ve:function(a,b,d,e,f,g,k,m,q){var t=null;q&&(t=Cd(m,k,f,g, +q));p.texSubImage2D(a,b,d,e,f,g,k,m,t)},ue:function(a,b){p.uniform1f(n.Bs[a],b)},te:function(a,b,d){if(b<=n.Ms)for(var e=n.Ns[b-1],f=0;f>2];else e=L.subarray(d>>2,d+4*b>>2);p.uniform1fv(n.Bs[a],e)},se:function(a,b){p.uniform1i(n.Bs[a],b)},re:function(a,b,d){p.uniform1iv(n.Bs[a],G.subarray(d>>2,d+4*b>>2))},qe:function(a,b,d){p.uniform2f(n.Bs[a],b,d)},pe:function(a,b,d){if(2*b<=n.Ms)for(var e=n.Ns[2*b-1],f=0;f<2*b;f+=2)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2];else e=L.subarray(d>> +2,d+8*b>>2);p.uniform2fv(n.Bs[a],e)},oe:function(a,b,d){p.uniform2i(n.Bs[a],b,d)},ne:function(a,b,d){p.uniform2iv(n.Bs[a],G.subarray(d>>2,d+8*b>>2))},me:function(a,b,d,e){p.uniform3f(n.Bs[a],b,d,e)},le:function(a,b,d){if(3*b<=n.Ms)for(var e=n.Ns[3*b-1],f=0;f<3*b;f+=3)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2],e[f+2]=L[d+(4*f+8)>>2];else e=L.subarray(d>>2,d+12*b>>2);p.uniform3fv(n.Bs[a],e)},ke:function(a,b,d,e){p.uniform3i(n.Bs[a],b,d,e)},je:function(a,b,d){p.uniform3iv(n.Bs[a],G.subarray(d>>2,d+12*b>> +2))},ie:function(a,b,d,e,f){p.uniform4f(n.Bs[a],b,d,e,f)},he:function(a,b,d){if(4*b<=n.Ms)for(var e=n.Ns[4*b-1],f=0;f<4*b;f+=4)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2],e[f+2]=L[d+(4*f+8)>>2],e[f+3]=L[d+(4*f+12)>>2];else e=L.subarray(d>>2,d+16*b>>2);p.uniform4fv(n.Bs[a],e)},ge:function(a,b,d,e,f){p.uniform4i(n.Bs[a],b,d,e,f)},fe:function(a,b,d){p.uniform4iv(n.Bs[a],G.subarray(d>>2,d+16*b>>2))},ee:function(a,b,d,e){if(4*b<=n.Ms)for(var f=n.Ns[4*b-1],g=0;g<4*b;g+=4)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>> +2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2];else f=L.subarray(e>>2,e+16*b>>2);p.uniformMatrix2fv(n.Bs[a],!!d,f)},de:function(a,b,d,e){if(9*b<=n.Ms)for(var f=n.Ns[9*b-1],g=0;g<9*b;g+=9)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>>2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2],f[g+4]=L[e+(4*g+16)>>2],f[g+5]=L[e+(4*g+20)>>2],f[g+6]=L[e+(4*g+24)>>2],f[g+7]=L[e+(4*g+28)>>2],f[g+8]=L[e+(4*g+32)>>2];else f=L.subarray(e>>2,e+36*b>>2);p.uniformMatrix3fv(n.Bs[a],!!d,f)},ce:function(a,b,d,e){if(16*b<=n.Ms)for(var f= +n.Ns[16*b-1],g=0;g<16*b;g+=16)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>>2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2],f[g+4]=L[e+(4*g+16)>>2],f[g+5]=L[e+(4*g+20)>>2],f[g+6]=L[e+(4*g+24)>>2],f[g+7]=L[e+(4*g+28)>>2],f[g+8]=L[e+(4*g+32)>>2],f[g+9]=L[e+(4*g+36)>>2],f[g+10]=L[e+(4*g+40)>>2],f[g+11]=L[e+(4*g+44)>>2],f[g+12]=L[e+(4*g+48)>>2],f[g+13]=L[e+(4*g+52)>>2],f[g+14]=L[e+(4*g+56)>>2],f[g+15]=L[e+(4*g+60)>>2];else f=L.subarray(e>>2,e+64*b>>2);p.uniformMatrix4fv(n.Bs[a],!!d,f)},be:function(a){p.useProgram(n.Gs[a])}, +ae:function(a){p.validateProgram(n.Gs[a])},$d:function(a,b){p.vertexAttrib1f(a,b)},_d:function(a,b){p.vertexAttrib1f(a,L[b>>2])},Zd:function(a,b,d){p.vertexAttrib2f(a,b,d)},Yd:function(a,b){p.vertexAttrib2f(a,L[b>>2],L[b+4>>2])},Xd:function(a,b,d,e){p.vertexAttrib3f(a,b,d,e)},Wd:function(a,b){p.vertexAttrib3f(a,L[b>>2],L[b+4>>2],L[b+8>>2])},Vd:function(a,b,d,e,f){p.vertexAttrib4f(a,b,d,e,f)},Ud:function(a,b){p.vertexAttrib4f(a,L[b>>2],L[b+4>>2],L[b+8>>2],L[b+12>>2])},Td:function(a,b){p.vertexAttribDivisor(a, +b)},Sd:function(a,b,d,e,f,g){p.vertexAttribPointer(a,b,d,!!e,f,g)},Rd:function(a,b,d,e){p.viewport(a,b,d,e)},Qd:function(a,b){Dd(a,b)},Pd:function(a,b,d){H.set(H.subarray(b,b+d),a)},Od:function(a){if(2147418112=b?b=Ba(2*b):b=Math.min(Ba((3*b+2147483648)/4),2147418112);var d=Ba(b);var e=r.buffer.byteLength;try{var f=-1!==pa.grow((d-e)/65536)?r.buffer=pa.buffer:null}catch(g){f=null}if(!f||f.byteLength!=b)return!1;r.buffer=buffer=f;Ea();Fa=b; +K[130032]=a;return!0},Nd:function(a,b){var d={};b>>=2;d.alpha=!!G[b];d.depth=!!G[b+1];d.stencil=!!G[b+2];d.antialias=!!G[b+3];d.premultipliedAlpha=!!G[b+4];d.preserveDrawingBuffer=!!G[b+5];d.powerPreference=Ed[G[b+6]];d.failIfMajorPerformanceCaveat=!!G[b+7];d.Ou=G[b+8];d.gw=G[b+9];d.Fu=G[b+10];d.dv=G[b+11];d.lw=G[b+12];d.mw=G[b+13];"number"===typeof a&&(a=E(a));a=a&&"#canvas"!==a?"undefined"!==typeof n&&n.Zt[a]?n.Zt[a]:Gd(a):"undefined"!==typeof n&&n.Zt.canvas?n.Zt.canvas:r.canvas;return!a||d.dv? +0:n.createContext(a,d)},Ld:function(){return n.currentContext?n.currentContext.handle:0},Kd:function(a){a>>=2;for(var b=0;14>b;++b)G[a+b]=0;G[a]=G[a+1]=G[a+3]=G[a+4]=G[a+8]=G[a+10]=1},hb:function(a){return n.Pu(a)?0:-5},Jd:function(a){if(!r.noExitRuntime&&(A=!0,r.onExit))r.onExit(a);r.quit(a,new ja(a))},Ma:Id,Id:function(a){p.activeTexture(a)},Hd:function(a,b){p.attachShader(n.Gs[a],n.Is[b])},Gd:function(a,b,d){p.bindAttribLocation(n.Gs[a],b,E(d))},Fd:function(a,b){p.bindBuffer(a,n.gt[b])},Ed:function(a, +b){p.bindFramebuffer(a,n.ht[b])},Dd:function(a,b){p.bindRenderbuffer(a,n.Ws[b])},Cd:function(a,b){p.bindTexture(a,n.Ts[b])},Bd:function(a,b,d,e){p.blendColor(a,b,d,e)},Ad:function(a){p.blendEquation(a)},zd:function(a,b){p.blendFunc(a,b)},yd:function(a,b,d,e){p.bufferData(a,d?H.subarray(d,d+b):b,e)},xd:function(a,b,d,e){p.bufferSubData(a,b,H.subarray(e,e+d))},wd:function(a){return p.checkFramebufferStatus(a)},gb:function(a){p.clear(a)},fb:function(a,b,d,e){p.clearColor(a,b,d,e)},eb:function(a){p.clearStencil(a)}, +vd:function(a,b,d,e){p.colorMask(!!a,!!b,!!d,!!e)},ud:function(a){p.compileShader(n.Is[a])},td:function(a,b,d,e,f,g,k,m){p.compressedTexImage2D(a,b,d,e,f,g,m?H.subarray(m,m+k):null)},sd:function(a,b,d,e,f,g,k,m,q){p.compressedTexSubImage2D(a,b,d,e,f,g,k,q?H.subarray(q,q+m):null)},rd:function(a,b,d,e,f,g,k,m){p.copyTexSubImage2D(a,b,d,e,f,g,k,m)},qd:function(){var a=n.lt(n.Gs),b=p.createProgram();b.name=a;n.Gs[a]=b;return a},pd:function(a){var b=n.lt(n.Is);n.Is[b]=p.createShader(a);return b},od:function(a){p.cullFace(a)}, +nd:function(a,b){for(var d=0;d>2],f=n.gt[e];f&&(p.deleteBuffer(f),f.name=0,n.gt[e]=null,e==n.gu&&(n.gu=0),e==n.hu&&(n.hu=0))}},md:function(a,b){for(var d=0;d>2],f=n.ht[e];f&&(p.deleteFramebuffer(f),f.name=0,n.ht[e]=null)}},ld:function(a){if(a){var b=n.Gs[a];b?(p.deleteProgram(b),b.name=0,n.Gs[a]=null,n.kt[a]=null):n.Ds(1281)}},kd:function(a,b){for(var d=0;d>2],f=n.Ws[e];f&&(p.deleteRenderbuffer(f),f.name=0,n.Ws[e]=null)}},jd:function(a){if(a){var b= +n.Is[a];b?(p.deleteShader(b),n.Is[a]=null):n.Ds(1281)}},id:function(a,b){for(var d=0;d>2],f=n.Ts[e];f&&(p.deleteTexture(f),f.name=0,n.Ts[e]=null)}},hd:function(a){p.depthMask(!!a)},gd:function(a){p.disable(a)},fd:function(a){p.disableVertexAttribArray(a)},ed:function(a,b,d){p.drawArrays(a,b,d)},dd:function(a,b,d,e){p.drawElements(a,b,d,e)},cd:function(a){p.enable(a)},bd:function(a){p.enableVertexAttribArray(a)},ad:function(){p.finish()},$c:function(){p.flush()},_c:function(a, +b,d,e){p.framebufferRenderbuffer(a,b,d,n.Ws[e])},Zc:function(a,b,d,e,f){p.framebufferTexture2D(a,b,d,n.Ts[e],f)},Yc:function(a){p.frontFace(a)},Xc:function(a,b){vd(a,b,"createBuffer",n.gt)},Wc:function(a,b){vd(a,b,"createFramebuffer",n.ht)},Vc:function(a,b){vd(a,b,"createRenderbuffer",n.Ws)},Uc:function(a,b){vd(a,b,"createTexture",n.Ts)},Tc:function(a){p.generateMipmap(a)},Sc:function(a,b,d){d?G[d>>2]=p.getBufferParameter(a,b):n.Ds(1281)},Rc:function(){if(n.mt){var a=n.mt;n.mt=0;return a}return p.getError()}, +Qc:function(a,b,d,e){a=p.getFramebufferAttachmentParameter(a,b,d);if(a instanceof WebGLRenderbuffer||a instanceof WebGLTexture)a=a.name|0;G[e>>2]=a},db:function(a,b){wd(a,b,"Integer")},Pc:function(a,b,d,e){a=p.getProgramInfoLog(n.Gs[a]);null===a&&(a="(unknown error)");0>2]=b)):d&&(G[d>>2]=0)},Oc:function(a,b,d){if(d)if(a>=n.fu)n.Ds(1281);else{var e=n.kt[a];if(e)if(35716==b)a=p.getProgramInfoLog(n.Gs[a]),null===a&&(a="(unknown error)"),G[d>>2]=a.length+1;else if(35719==b)G[d>> +2]=e.Qt;else if(35722==b){if(-1==e.ct){a=n.Gs[a];var f=p.getProgramParameter(a,35721);for(b=e.ct=0;b>2]=e.ct}else if(35381==b){if(-1==e.dt)for(a=n.Gs[a],f=p.getProgramParameter(a,35382),b=e.dt=0;b>2]=e.dt}else G[d>>2]=p.getProgramParameter(n.Gs[a],b);else n.Ds(1282)}else n.Ds(1281)},Nc:function(a,b,d){d?G[d>>2]=p.getRenderbufferParameter(a,b):n.Ds(1281)},Mc:function(a, +b,d,e){a=p.getShaderInfoLog(n.Is[a]);null===a&&(a="(unknown error)");0>2]=b)):d&&(G[d>>2]=0)},Lc:function(a,b,d,e){a=p.getShaderPrecisionFormat(a,b);G[d>>2]=a.rangeMin;G[d+4>>2]=a.rangeMax;G[e>>2]=a.precision},Kc:function(a,b,d){d?35716==b?(a=p.getShaderInfoLog(n.Is[a]),null===a&&(a="(unknown error)"),G[d>>2]=a.length+1):35720==b?(a=p.getShaderSource(n.Is[a]),G[d>>2]=null===a||0==a.length?0:a.length+1):G[d>>2]=p.getShaderParameter(n.Is[a],b):n.Ds(1281)},Jc:function(a){if(n.At[a])return n.At[a]; +switch(a){case 7939:var b=p.getSupportedExtensions();for(var d=[],e=0;e>2])},qc:function(a,b,d,e,f,g,k,m,q){var t=null;q&&(t=Cd(m,k,f,g,q));p.texSubImage2D(a,b,d,e,f,g,k,m,t)},pc:function(a,b){p.uniform1f(n.Bs[a],b)},oc:function(a,b,d){if(b<=n.Ms)for(var e=n.Ns[b-1],f=0;f>2];else e=L.subarray(d>>2,d+4*b>>2);p.uniform1fv(n.Bs[a],e)},nc:function(a,b){p.uniform1i(n.Bs[a],b)},mc:function(a,b,d){p.uniform1iv(n.Bs[a],G.subarray(d>>2,d+4*b>>2))},lc:function(a, +b,d){p.uniform2f(n.Bs[a],b,d)},kc:function(a,b,d){if(2*b<=n.Ms)for(var e=n.Ns[2*b-1],f=0;f<2*b;f+=2)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2];else e=L.subarray(d>>2,d+8*b>>2);p.uniform2fv(n.Bs[a],e)},jc:function(a,b,d){p.uniform2i(n.Bs[a],b,d)},ic:function(a,b,d){p.uniform2iv(n.Bs[a],G.subarray(d>>2,d+8*b>>2))},hc:function(a,b,d,e){p.uniform3f(n.Bs[a],b,d,e)},gc:function(a,b,d){if(3*b<=n.Ms)for(var e=n.Ns[3*b-1],f=0;f<3*b;f+=3)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2],e[f+2]=L[d+(4*f+8)>>2];else e=L.subarray(d>> +2,d+12*b>>2);p.uniform3fv(n.Bs[a],e)},fc:function(a,b,d,e){p.uniform3i(n.Bs[a],b,d,e)},ec:function(a,b,d){p.uniform3iv(n.Bs[a],G.subarray(d>>2,d+12*b>>2))},dc:function(a,b,d,e,f){p.uniform4f(n.Bs[a],b,d,e,f)},cc:function(a,b,d){if(4*b<=n.Ms)for(var e=n.Ns[4*b-1],f=0;f<4*b;f+=4)e[f]=L[d+4*f>>2],e[f+1]=L[d+(4*f+4)>>2],e[f+2]=L[d+(4*f+8)>>2],e[f+3]=L[d+(4*f+12)>>2];else e=L.subarray(d>>2,d+16*b>>2);p.uniform4fv(n.Bs[a],e)},bc:function(a,b,d,e,f){p.uniform4i(n.Bs[a],b,d,e,f)},ac:function(a,b,d){p.uniform4iv(n.Bs[a], +G.subarray(d>>2,d+16*b>>2))},$b:function(a,b,d,e){if(4*b<=n.Ms)for(var f=n.Ns[4*b-1],g=0;g<4*b;g+=4)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>>2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2];else f=L.subarray(e>>2,e+16*b>>2);p.uniformMatrix2fv(n.Bs[a],!!d,f)},_b:function(a,b,d,e){if(9*b<=n.Ms)for(var f=n.Ns[9*b-1],g=0;g<9*b;g+=9)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>>2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2],f[g+4]=L[e+(4*g+16)>>2],f[g+5]=L[e+(4*g+20)>>2],f[g+6]=L[e+(4*g+24)>>2],f[g+7]=L[e+(4*g+ +28)>>2],f[g+8]=L[e+(4*g+32)>>2];else f=L.subarray(e>>2,e+36*b>>2);p.uniformMatrix3fv(n.Bs[a],!!d,f)},Zb:function(a,b,d,e){if(16*b<=n.Ms)for(var f=n.Ns[16*b-1],g=0;g<16*b;g+=16)f[g]=L[e+4*g>>2],f[g+1]=L[e+(4*g+4)>>2],f[g+2]=L[e+(4*g+8)>>2],f[g+3]=L[e+(4*g+12)>>2],f[g+4]=L[e+(4*g+16)>>2],f[g+5]=L[e+(4*g+20)>>2],f[g+6]=L[e+(4*g+24)>>2],f[g+7]=L[e+(4*g+28)>>2],f[g+8]=L[e+(4*g+32)>>2],f[g+9]=L[e+(4*g+36)>>2],f[g+10]=L[e+(4*g+40)>>2],f[g+11]=L[e+(4*g+44)>>2],f[g+12]=L[e+(4*g+48)>>2],f[g+13]=L[e+(4*g+52)>> +2],f[g+14]=L[e+(4*g+56)>>2],f[g+15]=L[e+(4*g+60)>>2];else f=L.subarray(e>>2,e+64*b>>2);p.uniformMatrix4fv(n.Bs[a],!!d,f)},Yb:function(a){p.useProgram(n.Gs[a])},Xb:function(a,b){p.vertexAttrib1f(a,b)},Wb:function(a,b){p.vertexAttrib2f(a,L[b>>2],L[b+4>>2])},Vb:function(a,b){p.vertexAttrib3f(a,L[b>>2],L[b+4>>2],L[b+8>>2])},Ub:function(a,b){p.vertexAttrib4f(a,L[b>>2],L[b+4>>2],L[b+8>>2],L[b+12>>2])},Tb:function(a,b,d,e,f,g){p.vertexAttribPointer(a,b,d,!!e,f,g)},Sb:function(a,b,d,e){p.viewport(a,b,d,e)}, +cb:Jd,Rb:function(a){return Jd(a)},Qa:Kd,Qb:function(a){return Kd(a)},Ea:function(a){var b=Ld.Zs[a];Ld.Zs.splice(a,1);F(b)},Da:Ld,Pb:function(){v("trap!")},za:Ra,d:Dd,Ob:function(){return 0},Nb:function(){},bb:function(){},Mb:function(){},ab:function(){},Lb:function(a,b,d,e){return Rd(a,b,d,e)},Kb:function(){v("OOM")},a:520128},buffer);r.asm=ke; +var db=r.__GLOBAL__sub_I_bind_cpp=function(){return r.asm.hh.apply(null,arguments)},cb=r.__GLOBAL__sub_I_canvaskit_bindings_cpp=function(){return r.asm.ih.apply(null,arguments)};r.__Z6EqualsRK6SkPathS1_=function(){return r.asm.jh.apply(null,arguments)};r.__Z8CopyPathRK6SkPath=function(){return r.asm.kh.apply(null,arguments)};var ge=r.__ZSt18uncaught_exceptionv=function(){return r.asm.lh.apply(null,arguments)};r.___errno_location=function(){return r.asm.mh.apply(null,arguments)}; +var cd=r.___getTypeName=function(){return r.asm.nh.apply(null,arguments)},je=r._emscripten_GetProcAddress=function(){return r.asm.oh.apply(null,arguments)},X=r._free=function(){return r.asm.ph.apply(null,arguments)},va=r._malloc=function(){return r.asm.qh.apply(null,arguments)},he=r._memalign=function(){return r.asm.rh.apply(null,arguments)},ie=r._memset=function(){return r.asm.sh.apply(null,arguments)},Z=r._setThrew=function(){return r.asm.th.apply(null,arguments)}; +r._sk_3dview_apply_to_canvas=function(){return r.asm.uh.apply(null,arguments)};r._sk_3dview_destroy=function(){return r.asm.vh.apply(null,arguments)};r._sk_3dview_dot_with_normal=function(){return r.asm.wh.apply(null,arguments)};r._sk_3dview_get_matrix=function(){return r.asm.xh.apply(null,arguments)};r._sk_3dview_new=function(){return r.asm.yh.apply(null,arguments)};r._sk_3dview_restore=function(){return r.asm.zh.apply(null,arguments)}; +r._sk_3dview_rotate_x_degrees=function(){return r.asm.Ah.apply(null,arguments)};r._sk_3dview_rotate_x_radians=function(){return r.asm.Bh.apply(null,arguments)};r._sk_3dview_rotate_y_degrees=function(){return r.asm.Ch.apply(null,arguments)};r._sk_3dview_rotate_y_radians=function(){return r.asm.Dh.apply(null,arguments)};r._sk_3dview_rotate_z_degrees=function(){return r.asm.Eh.apply(null,arguments)};r._sk_3dview_rotate_z_radians=function(){return r.asm.Fh.apply(null,arguments)}; +r._sk_3dview_save=function(){return r.asm.Gh.apply(null,arguments)};r._sk_3dview_translate=function(){return r.asm.Hh.apply(null,arguments)};r._sk_bitmap_destructor=function(){return r.asm.Ih.apply(null,arguments)};r._sk_bitmap_erase=function(){return r.asm.Jh.apply(null,arguments)};r._sk_bitmap_erase_rect=function(){return r.asm.Kh.apply(null,arguments)};r._sk_bitmap_extract_alpha=function(){return r.asm.Lh.apply(null,arguments)}; +r._sk_bitmap_extract_subset=function(){return r.asm.Mh.apply(null,arguments)};r._sk_bitmap_get_addr=function(){return r.asm.Nh.apply(null,arguments)};r._sk_bitmap_get_addr_16=function(){return r.asm.Oh.apply(null,arguments)};r._sk_bitmap_get_addr_32=function(){return r.asm.Ph.apply(null,arguments)};r._sk_bitmap_get_addr_8=function(){return r.asm.Qh.apply(null,arguments)};r._sk_bitmap_get_byte_count=function(){return r.asm.Rh.apply(null,arguments)}; +r._sk_bitmap_get_info=function(){return r.asm.Sh.apply(null,arguments)};r._sk_bitmap_get_pixel_color=function(){return r.asm.Th.apply(null,arguments)};r._sk_bitmap_get_pixel_colors=function(){return r.asm.Uh.apply(null,arguments)};r._sk_bitmap_get_pixels=function(){return r.asm.Vh.apply(null,arguments)};r._sk_bitmap_get_row_bytes=function(){return r.asm.Wh.apply(null,arguments)};r._sk_bitmap_install_mask_pixels=function(){return r.asm.Xh.apply(null,arguments)}; +r._sk_bitmap_install_pixels=function(){return r.asm.Yh.apply(null,arguments)};r._sk_bitmap_install_pixels_with_pixmap=function(){return r.asm.Zh.apply(null,arguments)};r._sk_bitmap_is_immutable=function(){return r.asm._h.apply(null,arguments)};r._sk_bitmap_is_null=function(){return r.asm.$h.apply(null,arguments)};r._sk_bitmap_is_volatile=function(){return r.asm.ai.apply(null,arguments)};r._sk_bitmap_new=function(){return r.asm.bi.apply(null,arguments)}; +r._sk_bitmap_notify_pixels_changed=function(){return r.asm.ci.apply(null,arguments)};r._sk_bitmap_peek_pixels=function(){return r.asm.di.apply(null,arguments)};r._sk_bitmap_ready_to_draw=function(){return r.asm.ei.apply(null,arguments)};r._sk_bitmap_reset=function(){return r.asm.fi.apply(null,arguments)};r._sk_bitmap_set_immutable=function(){return r.asm.gi.apply(null,arguments)};r._sk_bitmap_set_pixel_color=function(){return r.asm.hi.apply(null,arguments)}; +r._sk_bitmap_set_pixel_colors=function(){return r.asm.ii.apply(null,arguments)};r._sk_bitmap_set_pixels=function(){return r.asm.ji.apply(null,arguments)};r._sk_bitmap_set_volatile=function(){return r.asm.ki.apply(null,arguments)};r._sk_bitmap_swap=function(){return r.asm.li.apply(null,arguments)};r._sk_bitmap_try_alloc_pixels=function(){return r.asm.mi.apply(null,arguments)};r._sk_bitmap_try_alloc_pixels_with_flags=function(){return r.asm.ni.apply(null,arguments)}; +r._sk_canvas_clip_path_with_operation=function(){return r.asm.oi.apply(null,arguments)};r._sk_canvas_clip_rect_with_operation=function(){return r.asm.pi.apply(null,arguments)};r._sk_canvas_clip_region=function(){return r.asm.qi.apply(null,arguments)};r._sk_canvas_clip_rrect_with_operation=function(){return r.asm.ri.apply(null,arguments)};r._sk_canvas_concat=function(){return r.asm.si.apply(null,arguments)};r._sk_canvas_destroy=function(){return r.asm.ti.apply(null,arguments)}; +r._sk_canvas_draw_annotation=function(){return r.asm.ui.apply(null,arguments)};r._sk_canvas_draw_bitmap=function(){return r.asm.vi.apply(null,arguments)};r._sk_canvas_draw_bitmap_lattice=function(){return r.asm.wi.apply(null,arguments)};r._sk_canvas_draw_bitmap_nine=function(){return r.asm.xi.apply(null,arguments)};r._sk_canvas_draw_bitmap_rect=function(){return r.asm.yi.apply(null,arguments)};r._sk_canvas_draw_circle=function(){return r.asm.zi.apply(null,arguments)}; +r._sk_canvas_draw_color=function(){return r.asm.Ai.apply(null,arguments)};r._sk_canvas_draw_drawable=function(){return r.asm.Bi.apply(null,arguments)};r._sk_canvas_draw_image=function(){return r.asm.Ci.apply(null,arguments)};r._sk_canvas_draw_image_lattice=function(){return r.asm.Di.apply(null,arguments)};r._sk_canvas_draw_image_nine=function(){return r.asm.Ei.apply(null,arguments)};r._sk_canvas_draw_image_rect=function(){return r.asm.Fi.apply(null,arguments)}; +r._sk_canvas_draw_line=function(){return r.asm.Gi.apply(null,arguments)};r._sk_canvas_draw_link_destination_annotation=function(){return r.asm.Hi.apply(null,arguments)};r._sk_canvas_draw_named_destination_annotation=function(){return r.asm.Ii.apply(null,arguments)};r._sk_canvas_draw_oval=function(){return r.asm.Ji.apply(null,arguments)};r._sk_canvas_draw_paint=function(){return r.asm.Ki.apply(null,arguments)};r._sk_canvas_draw_path=function(){return r.asm.Li.apply(null,arguments)}; +r._sk_canvas_draw_picture=function(){return r.asm.Mi.apply(null,arguments)};r._sk_canvas_draw_point=function(){return r.asm.Ni.apply(null,arguments)};r._sk_canvas_draw_points=function(){return r.asm.Oi.apply(null,arguments)};r._sk_canvas_draw_pos_text=function(){return r.asm.Pi.apply(null,arguments)};r._sk_canvas_draw_rect=function(){return r.asm.Qi.apply(null,arguments)};r._sk_canvas_draw_region=function(){return r.asm.Ri.apply(null,arguments)}; +r._sk_canvas_draw_round_rect=function(){return r.asm.Si.apply(null,arguments)};r._sk_canvas_draw_rrect=function(){return r.asm.Ti.apply(null,arguments)};r._sk_canvas_draw_text=function(){return r.asm.Ui.apply(null,arguments)};r._sk_canvas_draw_text_blob=function(){return r.asm.Vi.apply(null,arguments)};r._sk_canvas_draw_text_on_path=function(){return r.asm.Wi.apply(null,arguments)};r._sk_canvas_draw_url_annotation=function(){return r.asm.Xi.apply(null,arguments)}; +r._sk_canvas_draw_vertices=function(){return r.asm.Yi.apply(null,arguments)};r._sk_canvas_flush=function(){return r.asm.Zi.apply(null,arguments)};r._sk_canvas_get_device_clip_bounds=function(){return r.asm._i.apply(null,arguments)};r._sk_canvas_get_local_clip_bounds=function(){return r.asm.$i.apply(null,arguments)};r._sk_canvas_get_save_count=function(){return r.asm.aj.apply(null,arguments)};r._sk_canvas_get_total_matrix=function(){return r.asm.bj.apply(null,arguments)}; +r._sk_canvas_new_from_bitmap=function(){return r.asm.cj.apply(null,arguments)};r._sk_canvas_quick_reject=function(){return r.asm.dj.apply(null,arguments)};r._sk_canvas_reset_matrix=function(){return r.asm.ej.apply(null,arguments)};r._sk_canvas_restore=function(){return r.asm.fj.apply(null,arguments)};r._sk_canvas_restore_to_count=function(){return r.asm.gj.apply(null,arguments)};r._sk_canvas_rotate_degrees=function(){return r.asm.hj.apply(null,arguments)}; +r._sk_canvas_rotate_radians=function(){return r.asm.ij.apply(null,arguments)};r._sk_canvas_save=function(){return r.asm.jj.apply(null,arguments)};r._sk_canvas_save_layer=function(){return r.asm.kj.apply(null,arguments)};r._sk_canvas_scale=function(){return r.asm.lj.apply(null,arguments)};r._sk_canvas_set_matrix=function(){return r.asm.mj.apply(null,arguments)};r._sk_canvas_skew=function(){return r.asm.nj.apply(null,arguments)};r._sk_canvas_translate=function(){return r.asm.oj.apply(null,arguments)}; +r._sk_codec_destroy=function(){return r.asm.pj.apply(null,arguments)};r._sk_codec_get_encoded_format=function(){return r.asm.qj.apply(null,arguments)};r._sk_codec_get_frame_count=function(){return r.asm.rj.apply(null,arguments)};r._sk_codec_get_frame_info=function(){return r.asm.sj.apply(null,arguments)};r._sk_codec_get_frame_info_for_index=function(){return r.asm.tj.apply(null,arguments)};r._sk_codec_get_info=function(){return r.asm.uj.apply(null,arguments)}; +r._sk_codec_get_origin=function(){return r.asm.vj.apply(null,arguments)};r._sk_codec_get_pixels=function(){return r.asm.wj.apply(null,arguments)};r._sk_codec_get_repetition_count=function(){return r.asm.xj.apply(null,arguments)};r._sk_codec_get_scaled_dimensions=function(){return r.asm.yj.apply(null,arguments)};r._sk_codec_get_scanline_order=function(){return r.asm.zj.apply(null,arguments)};r._sk_codec_get_scanlines=function(){return r.asm.Aj.apply(null,arguments)}; +r._sk_codec_get_valid_subset=function(){return r.asm.Bj.apply(null,arguments)};r._sk_codec_incremental_decode=function(){return r.asm.Cj.apply(null,arguments)};r._sk_codec_min_buffered_bytes_needed=function(){return r.asm.Dj.apply(null,arguments)};r._sk_codec_new_from_data=function(){return r.asm.Ej.apply(null,arguments)};r._sk_codec_new_from_stream=function(){return r.asm.Fj.apply(null,arguments)};r._sk_codec_next_scanline=function(){return r.asm.Gj.apply(null,arguments)}; +r._sk_codec_output_scanline=function(){return r.asm.Hj.apply(null,arguments)};r._sk_codec_skip_scanlines=function(){return r.asm.Ij.apply(null,arguments)};r._sk_codec_start_incremental_decode=function(){return r.asm.Jj.apply(null,arguments)};r._sk_codec_start_scanline_decode=function(){return r.asm.Kj.apply(null,arguments)};r._sk_color_get_bit_shift=function(){return r.asm.Lj.apply(null,arguments)};r._sk_color_premultiply=function(){return r.asm.Mj.apply(null,arguments)}; +r._sk_color_premultiply_array=function(){return r.asm.Nj.apply(null,arguments)};r._sk_color_unpremultiply=function(){return r.asm.Oj.apply(null,arguments)};r._sk_color_unpremultiply_array=function(){return r.asm.Pj.apply(null,arguments)};r._sk_colorfilter_new_color_matrix=function(){return r.asm.Qj.apply(null,arguments)};r._sk_colorfilter_new_compose=function(){return r.asm.Rj.apply(null,arguments)};r._sk_colorfilter_new_high_contrast=function(){return r.asm.Sj.apply(null,arguments)}; +r._sk_colorfilter_new_lighting=function(){return r.asm.Tj.apply(null,arguments)};r._sk_colorfilter_new_luma_color=function(){return r.asm.Uj.apply(null,arguments)};r._sk_colorfilter_new_mode=function(){return r.asm.Vj.apply(null,arguments)};r._sk_colorfilter_new_table=function(){return r.asm.Wj.apply(null,arguments)};r._sk_colorfilter_new_table_argb=function(){return r.asm.Xj.apply(null,arguments)};r._sk_colorfilter_unref=function(){return r.asm.Yj.apply(null,arguments)}; +r._sk_colorspace_as_from_xyzd50=function(){return r.asm.Zj.apply(null,arguments)};r._sk_colorspace_as_to_xyzd50=function(){return r.asm._j.apply(null,arguments)};r._sk_colorspace_equals=function(){return r.asm.$j.apply(null,arguments)};r._sk_colorspace_gamma_close_to_srgb=function(){return r.asm.ak.apply(null,arguments)};r._sk_colorspace_gamma_get_gamma_named=function(){return r.asm.bk.apply(null,arguments)};r._sk_colorspace_gamma_get_type=function(){return r.asm.ck.apply(null,arguments)}; +r._sk_colorspace_gamma_is_linear=function(){return r.asm.dk.apply(null,arguments)};r._sk_colorspace_is_numerical_transfer_fn=function(){return r.asm.ek.apply(null,arguments)};r._sk_colorspace_is_srgb=function(){return r.asm.fk.apply(null,arguments)};r._sk_colorspace_new_icc=function(){return r.asm.gk.apply(null,arguments)};r._sk_colorspace_new_rgb_with_coeffs=function(){return r.asm.hk.apply(null,arguments)};r._sk_colorspace_new_rgb_with_coeffs_and_gamut=function(){return r.asm.ik.apply(null,arguments)}; +r._sk_colorspace_new_rgb_with_gamma=function(){return r.asm.jk.apply(null,arguments)};r._sk_colorspace_new_rgb_with_gamma_and_gamut=function(){return r.asm.kk.apply(null,arguments)};r._sk_colorspace_new_rgb_with_gamma_named=function(){return r.asm.lk.apply(null,arguments)};r._sk_colorspace_new_srgb=function(){return r.asm.mk.apply(null,arguments)};r._sk_colorspace_new_srgb_linear=function(){return r.asm.nk.apply(null,arguments)};r._sk_colorspace_to_xyzd50=function(){return r.asm.ok.apply(null,arguments)}; +r._sk_colorspace_transfer_fn_invert=function(){return r.asm.pk.apply(null,arguments)};r._sk_colorspace_transfer_fn_transform=function(){return r.asm.qk.apply(null,arguments)};r._sk_colorspace_unref=function(){return r.asm.rk.apply(null,arguments)};r._sk_colorspaceprimaries_to_xyzd50=function(){return r.asm.sk.apply(null,arguments)};r._sk_colortable_count=function(){return r.asm.tk.apply(null,arguments)};r._sk_colortable_new=function(){return r.asm.uk.apply(null,arguments)}; +r._sk_colortable_read_colors=function(){return r.asm.vk.apply(null,arguments)};r._sk_colortable_unref=function(){return r.asm.wk.apply(null,arguments)};r._sk_colortype_get_default_8888=function(){return r.asm.xk.apply(null,arguments)};r._sk_filestream_destroy=function(){return r.asm.yk.apply(null,arguments)};r._sk_filestream_is_valid=function(){return r.asm.zk.apply(null,arguments)};r._sk_filestream_new=function(){return r.asm.Ak.apply(null,arguments)}; +r._sk_fontmgr_count_families=function(){return r.asm.Bk.apply(null,arguments)};r._sk_fontmgr_create_default=function(){return r.asm.Ck.apply(null,arguments)};r._sk_fontmgr_create_from_data=function(){return r.asm.Dk.apply(null,arguments)};r._sk_fontmgr_create_from_file=function(){return r.asm.Ek.apply(null,arguments)};r._sk_fontmgr_create_from_stream=function(){return r.asm.Fk.apply(null,arguments)};r._sk_fontmgr_create_styleset=function(){return r.asm.Gk.apply(null,arguments)}; +r._sk_fontmgr_get_family_name=function(){return r.asm.Hk.apply(null,arguments)};r._sk_fontmgr_match_face_style=function(){return r.asm.Ik.apply(null,arguments)};r._sk_fontmgr_match_family=function(){return r.asm.Jk.apply(null,arguments)};r._sk_fontmgr_match_family_style=function(){return r.asm.Kk.apply(null,arguments)};r._sk_fontmgr_match_family_style_character=function(){return r.asm.Lk.apply(null,arguments)};r._sk_fontmgr_ref_default=function(){return r.asm.Mk.apply(null,arguments)}; +r._sk_fontmgr_unref=function(){return r.asm.Nk.apply(null,arguments)};r._sk_fontstyle_delete=function(){return r.asm.Ok.apply(null,arguments)};r._sk_fontstyle_get_slant=function(){return r.asm.Pk.apply(null,arguments)};r._sk_fontstyle_get_weight=function(){return r.asm.Qk.apply(null,arguments)};r._sk_fontstyle_get_width=function(){return r.asm.Rk.apply(null,arguments)};r._sk_fontstyle_new=function(){return r.asm.Sk.apply(null,arguments)}; +r._sk_fontstyleset_create_empty=function(){return r.asm.Tk.apply(null,arguments)};r._sk_fontstyleset_create_typeface=function(){return r.asm.Uk.apply(null,arguments)};r._sk_fontstyleset_get_count=function(){return r.asm.Vk.apply(null,arguments)};r._sk_fontstyleset_get_style=function(){return r.asm.Wk.apply(null,arguments)};r._sk_fontstyleset_match_style=function(){return r.asm.Xk.apply(null,arguments)};r._sk_fontstyleset_unref=function(){return r.asm.Yk.apply(null,arguments)}; +r._sk_imagefilter_croprect_destructor=function(){return r.asm.Zk.apply(null,arguments)};r._sk_imagefilter_croprect_get_flags=function(){return r.asm._k.apply(null,arguments)};r._sk_imagefilter_croprect_get_rect=function(){return r.asm.$k.apply(null,arguments)};r._sk_imagefilter_croprect_new=function(){return r.asm.al.apply(null,arguments)};r._sk_imagefilter_croprect_new_with_rect=function(){return r.asm.bl.apply(null,arguments)}; +r._sk_imagefilter_new_alpha_threshold=function(){return r.asm.cl.apply(null,arguments)};r._sk_imagefilter_new_arithmetic=function(){return r.asm.dl.apply(null,arguments)};r._sk_imagefilter_new_blur=function(){return r.asm.el.apply(null,arguments)};r._sk_imagefilter_new_color_filter=function(){return r.asm.fl.apply(null,arguments)};r._sk_imagefilter_new_compose=function(){return r.asm.gl.apply(null,arguments)};r._sk_imagefilter_new_dilate=function(){return r.asm.hl.apply(null,arguments)}; +r._sk_imagefilter_new_displacement_map_effect=function(){return r.asm.il.apply(null,arguments)};r._sk_imagefilter_new_distant_lit_diffuse=function(){return r.asm.jl.apply(null,arguments)};r._sk_imagefilter_new_distant_lit_specular=function(){return r.asm.kl.apply(null,arguments)};r._sk_imagefilter_new_drop_shadow=function(){return r.asm.ll.apply(null,arguments)};r._sk_imagefilter_new_erode=function(){return r.asm.ml.apply(null,arguments)}; +r._sk_imagefilter_new_image_source=function(){return r.asm.nl.apply(null,arguments)};r._sk_imagefilter_new_image_source_default=function(){return r.asm.ol.apply(null,arguments)};r._sk_imagefilter_new_magnifier=function(){return r.asm.pl.apply(null,arguments)};r._sk_imagefilter_new_matrix=function(){return r.asm.ql.apply(null,arguments)};r._sk_imagefilter_new_matrix_convolution=function(){return r.asm.rl.apply(null,arguments)};r._sk_imagefilter_new_merge=function(){return r.asm.sl.apply(null,arguments)}; +r._sk_imagefilter_new_offset=function(){return r.asm.tl.apply(null,arguments)};r._sk_imagefilter_new_paint=function(){return r.asm.ul.apply(null,arguments)};r._sk_imagefilter_new_picture=function(){return r.asm.vl.apply(null,arguments)};r._sk_imagefilter_new_picture_with_croprect=function(){return r.asm.wl.apply(null,arguments)};r._sk_imagefilter_new_point_lit_diffuse=function(){return r.asm.xl.apply(null,arguments)};r._sk_imagefilter_new_point_lit_specular=function(){return r.asm.yl.apply(null,arguments)}; +r._sk_imagefilter_new_spot_lit_diffuse=function(){return r.asm.zl.apply(null,arguments)};r._sk_imagefilter_new_spot_lit_specular=function(){return r.asm.Al.apply(null,arguments)};r._sk_imagefilter_new_tile=function(){return r.asm.Bl.apply(null,arguments)};r._sk_imagefilter_new_xfermode=function(){return r.asm.Cl.apply(null,arguments)};r._sk_imagefilter_unref=function(){return r.asm.Dl.apply(null,arguments)};r._sk_manageddrawable_destroy=function(){return r.asm.El.apply(null,arguments)}; +r._sk_manageddrawable_new=function(){return r.asm.Fl.apply(null,arguments)};r._sk_manageddrawable_set_delegates=function(){return r.asm.Gl.apply(null,arguments)};r._sk_managedstream_destroy=function(){return r.asm.Hl.apply(null,arguments)};r._sk_managedstream_new=function(){return r.asm.Il.apply(null,arguments)};r._sk_managedstream_set_delegates=function(){return r.asm.Jl.apply(null,arguments)};r._sk_managedwstream_destroy=function(){return r.asm.Kl.apply(null,arguments)}; +r._sk_managedwstream_new=function(){return r.asm.Ll.apply(null,arguments)};r._sk_managedwstream_set_delegates=function(){return r.asm.Ml.apply(null,arguments)};r._sk_maskfilter_new_blur=function(){return r.asm.Nl.apply(null,arguments)};r._sk_maskfilter_new_blur_with_flags=function(){return r.asm.Ol.apply(null,arguments)};r._sk_maskfilter_new_clip=function(){return r.asm.Pl.apply(null,arguments)};r._sk_maskfilter_new_gamma=function(){return r.asm.Ql.apply(null,arguments)}; +r._sk_maskfilter_new_table=function(){return r.asm.Rl.apply(null,arguments)};r._sk_maskfilter_unref=function(){return r.asm.Sl.apply(null,arguments)};r._sk_matrix44_as_col_major=function(){return r.asm.Tl.apply(null,arguments)};r._sk_matrix44_as_row_major=function(){return r.asm.Ul.apply(null,arguments)};r._sk_matrix44_destroy=function(){return r.asm.Vl.apply(null,arguments)};r._sk_matrix44_determinant=function(){return r.asm.Wl.apply(null,arguments)}; +r._sk_matrix44_equals=function(){return r.asm.Xl.apply(null,arguments)};r._sk_matrix44_get=function(){return r.asm.Yl.apply(null,arguments)};r._sk_matrix44_get_type=function(){return r.asm.Zl.apply(null,arguments)};r._sk_matrix44_invert=function(){return r.asm._l.apply(null,arguments)};r._sk_matrix44_map2=function(){return r.asm.$l.apply(null,arguments)};r._sk_matrix44_map_scalars=function(){return r.asm.am.apply(null,arguments)};r._sk_matrix44_new=function(){return r.asm.bm.apply(null,arguments)}; +r._sk_matrix44_new_concat=function(){return r.asm.cm.apply(null,arguments)};r._sk_matrix44_new_copy=function(){return r.asm.dm.apply(null,arguments)};r._sk_matrix44_new_identity=function(){return r.asm.em.apply(null,arguments)};r._sk_matrix44_new_matrix=function(){return r.asm.fm.apply(null,arguments)};r._sk_matrix44_post_concat=function(){return r.asm.gm.apply(null,arguments)};r._sk_matrix44_post_scale=function(){return r.asm.hm.apply(null,arguments)}; +r._sk_matrix44_post_translate=function(){return r.asm.im.apply(null,arguments)};r._sk_matrix44_pre_concat=function(){return r.asm.jm.apply(null,arguments)};r._sk_matrix44_pre_scale=function(){return r.asm.km.apply(null,arguments)};r._sk_matrix44_pre_translate=function(){return r.asm.lm.apply(null,arguments)};r._sk_matrix44_preserves_2d_axis_alignment=function(){return r.asm.mm.apply(null,arguments)};r._sk_matrix44_set=function(){return r.asm.nm.apply(null,arguments)}; +r._sk_matrix44_set_col_major=function(){return r.asm.om.apply(null,arguments)};r._sk_matrix44_set_concat=function(){return r.asm.pm.apply(null,arguments)};r._sk_matrix44_set_identity=function(){return r.asm.qm.apply(null,arguments)};r._sk_matrix44_set_rotate_about_degrees=function(){return r.asm.rm.apply(null,arguments)};r._sk_matrix44_set_rotate_about_radians=function(){return r.asm.sm.apply(null,arguments)};r._sk_matrix44_set_rotate_about_radians_unit=function(){return r.asm.tm.apply(null,arguments)}; +r._sk_matrix44_set_row_major=function(){return r.asm.um.apply(null,arguments)};r._sk_matrix44_set_scale=function(){return r.asm.vm.apply(null,arguments)};r._sk_matrix44_set_translate=function(){return r.asm.wm.apply(null,arguments)};r._sk_matrix44_to_matrix=function(){return r.asm.xm.apply(null,arguments)};r._sk_matrix44_transpose=function(){return r.asm.ym.apply(null,arguments)};r._sk_matrix_concat=function(){return r.asm.zm.apply(null,arguments)}; +r._sk_matrix_map_points=function(){return r.asm.Am.apply(null,arguments)};r._sk_matrix_map_radius=function(){return r.asm.Bm.apply(null,arguments)};r._sk_matrix_map_rect=function(){return r.asm.Cm.apply(null,arguments)};r._sk_matrix_map_vector=function(){return r.asm.Dm.apply(null,arguments)};r._sk_matrix_map_vectors=function(){return r.asm.Em.apply(null,arguments)};r._sk_matrix_map_xy=function(){return r.asm.Fm.apply(null,arguments)}; +r._sk_matrix_post_concat=function(){return r.asm.Gm.apply(null,arguments)};r._sk_matrix_pre_concat=function(){return r.asm.Hm.apply(null,arguments)};r._sk_matrix_try_invert=function(){return r.asm.Im.apply(null,arguments)};r._sk_memorystream_destroy=function(){return r.asm.Jm.apply(null,arguments)};r._sk_memorystream_new=function(){return r.asm.Km.apply(null,arguments)};r._sk_memorystream_new_with_data=function(){return r.asm.Lm.apply(null,arguments)}; +r._sk_memorystream_new_with_length=function(){return r.asm.Mm.apply(null,arguments)};r._sk_memorystream_new_with_skdata=function(){return r.asm.Nm.apply(null,arguments)};r._sk_memorystream_set_memory=function(){return r.asm.Om.apply(null,arguments)};r._sk_paint_break_text=function(){return r.asm.Pm.apply(null,arguments)};r._sk_paint_clone=function(){return r.asm.Qm.apply(null,arguments)};r._sk_paint_contains_text=function(){return r.asm.Rm.apply(null,arguments)}; +r._sk_paint_count_text=function(){return r.asm.Sm.apply(null,arguments)};r._sk_paint_delete=function(){return r.asm.Tm.apply(null,arguments)};r._sk_paint_get_blendmode=function(){return r.asm.Um.apply(null,arguments)};r._sk_paint_get_color=function(){return r.asm.Vm.apply(null,arguments)};r._sk_paint_get_colorfilter=function(){return r.asm.Wm.apply(null,arguments)};r._sk_paint_get_fill_path=function(){return r.asm.Xm.apply(null,arguments)}; +r._sk_paint_get_filter_quality=function(){return r.asm.Ym.apply(null,arguments)};r._sk_paint_get_fontmetrics=function(){return r.asm.Zm.apply(null,arguments)};r._sk_paint_get_hinting=function(){return r.asm._m.apply(null,arguments)};r._sk_paint_get_imagefilter=function(){return r.asm.$m.apply(null,arguments)};r._sk_paint_get_maskfilter=function(){return r.asm.an.apply(null,arguments)};r._sk_paint_get_path_effect=function(){return r.asm.bn.apply(null,arguments)}; +r._sk_paint_get_pos_text_blob_intercepts=function(){return r.asm.cn.apply(null,arguments)};r._sk_paint_get_pos_text_h_intercepts=function(){return r.asm.dn.apply(null,arguments)};r._sk_paint_get_pos_text_intercepts=function(){return r.asm.en.apply(null,arguments)};r._sk_paint_get_pos_text_path=function(){return r.asm.fn.apply(null,arguments)};r._sk_paint_get_shader=function(){return r.asm.gn.apply(null,arguments)};r._sk_paint_get_stroke_cap=function(){return r.asm.hn.apply(null,arguments)}; +r._sk_paint_get_stroke_join=function(){return r.asm.jn.apply(null,arguments)};r._sk_paint_get_stroke_miter=function(){return r.asm.kn.apply(null,arguments)};r._sk_paint_get_stroke_width=function(){return r.asm.ln.apply(null,arguments)};r._sk_paint_get_style=function(){return r.asm.mn.apply(null,arguments)};r._sk_paint_get_text_align=function(){return r.asm.nn.apply(null,arguments)};r._sk_paint_get_text_encoding=function(){return r.asm.on.apply(null,arguments)}; +r._sk_paint_get_text_intercepts=function(){return r.asm.pn.apply(null,arguments)};r._sk_paint_get_text_path=function(){return r.asm.qn.apply(null,arguments)};r._sk_paint_get_text_scale_x=function(){return r.asm.rn.apply(null,arguments)};r._sk_paint_get_text_skew_x=function(){return r.asm.sn.apply(null,arguments)};r._sk_paint_get_text_widths=function(){return r.asm.tn.apply(null,arguments)};r._sk_paint_get_textsize=function(){return r.asm.un.apply(null,arguments)}; +r._sk_paint_get_typeface=function(){return r.asm.vn.apply(null,arguments)};r._sk_paint_is_antialias=function(){return r.asm.wn.apply(null,arguments)};r._sk_paint_is_autohinted=function(){return r.asm.xn.apply(null,arguments)};r._sk_paint_is_dev_kern_text=function(){return r.asm.yn.apply(null,arguments)};r._sk_paint_is_dither=function(){return r.asm.zn.apply(null,arguments)};r._sk_paint_is_embedded_bitmap_text=function(){return r.asm.An.apply(null,arguments)}; +r._sk_paint_is_fake_bold_text=function(){return r.asm.Bn.apply(null,arguments)};r._sk_paint_is_lcd_render_text=function(){return r.asm.Cn.apply(null,arguments)};r._sk_paint_is_linear_text=function(){return r.asm.Dn.apply(null,arguments)};r._sk_paint_is_subpixel_text=function(){return r.asm.En.apply(null,arguments)};r._sk_paint_is_verticaltext=function(){return r.asm.Fn.apply(null,arguments)};r._sk_paint_measure_text=function(){return r.asm.Gn.apply(null,arguments)}; +r._sk_paint_new=function(){return r.asm.Hn.apply(null,arguments)};r._sk_paint_reset=function(){return r.asm.In.apply(null,arguments)};r._sk_paint_set_antialias=function(){return r.asm.Jn.apply(null,arguments)};r._sk_paint_set_autohinted=function(){return r.asm.Kn.apply(null,arguments)};r._sk_paint_set_blendmode=function(){return r.asm.Ln.apply(null,arguments)};r._sk_paint_set_color=function(){return r.asm.Mn.apply(null,arguments)}; +r._sk_paint_set_colorfilter=function(){return r.asm.Nn.apply(null,arguments)};r._sk_paint_set_dev_kern_text=function(){return r.asm.On.apply(null,arguments)};r._sk_paint_set_dither=function(){return r.asm.Pn.apply(null,arguments)};r._sk_paint_set_embedded_bitmap_text=function(){return r.asm.Qn.apply(null,arguments)};r._sk_paint_set_fake_bold_text=function(){return r.asm.Rn.apply(null,arguments)};r._sk_paint_set_filter_quality=function(){return r.asm.Sn.apply(null,arguments)}; +r._sk_paint_set_hinting=function(){return r.asm.Tn.apply(null,arguments)};r._sk_paint_set_imagefilter=function(){return r.asm.Un.apply(null,arguments)};r._sk_paint_set_lcd_render_text=function(){return r.asm.Vn.apply(null,arguments)};r._sk_paint_set_linear_text=function(){return r.asm.Wn.apply(null,arguments)};r._sk_paint_set_maskfilter=function(){return r.asm.Xn.apply(null,arguments)};r._sk_paint_set_path_effect=function(){return r.asm.Yn.apply(null,arguments)}; +r._sk_paint_set_shader=function(){return r.asm.Zn.apply(null,arguments)};r._sk_paint_set_stroke_cap=function(){return r.asm._n.apply(null,arguments)};r._sk_paint_set_stroke_join=function(){return r.asm.$n.apply(null,arguments)};r._sk_paint_set_stroke_miter=function(){return r.asm.ao.apply(null,arguments)};r._sk_paint_set_stroke_width=function(){return r.asm.bo.apply(null,arguments)};r._sk_paint_set_style=function(){return r.asm.co.apply(null,arguments)}; +r._sk_paint_set_subpixel_text=function(){return r.asm.eo.apply(null,arguments)};r._sk_paint_set_text_align=function(){return r.asm.fo.apply(null,arguments)};r._sk_paint_set_text_encoding=function(){return r.asm.go.apply(null,arguments)};r._sk_paint_set_text_scale_x=function(){return r.asm.ho.apply(null,arguments)};r._sk_paint_set_text_skew_x=function(){return r.asm.io.apply(null,arguments)};r._sk_paint_set_textsize=function(){return r.asm.jo.apply(null,arguments)}; +r._sk_paint_set_typeface=function(){return r.asm.ko.apply(null,arguments)};r._sk_paint_set_verticaltext=function(){return r.asm.lo.apply(null,arguments)};r._sk_paint_text_to_glyphs=function(){return r.asm.mo.apply(null,arguments)};r._sk_path_add_arc=function(){return r.asm.no.apply(null,arguments)};r._sk_path_add_circle=function(){return r.asm.oo.apply(null,arguments)};r._sk_path_add_oval=function(){return r.asm.po.apply(null,arguments)};r._sk_path_add_path=function(){return r.asm.qo.apply(null,arguments)}; +r._sk_path_add_path_matrix=function(){return r.asm.ro.apply(null,arguments)};r._sk_path_add_path_offset=function(){return r.asm.so.apply(null,arguments)};r._sk_path_add_path_reverse=function(){return r.asm.to.apply(null,arguments)};r._sk_path_add_poly=function(){return r.asm.uo.apply(null,arguments)};r._sk_path_add_rect=function(){return r.asm.vo.apply(null,arguments)};r._sk_path_add_rect_start=function(){return r.asm.wo.apply(null,arguments)}; +r._sk_path_add_rounded_rect=function(){return r.asm.xo.apply(null,arguments)};r._sk_path_add_rrect=function(){return r.asm.yo.apply(null,arguments)};r._sk_path_add_rrect_start=function(){return r.asm.zo.apply(null,arguments)};r._sk_path_arc_to=function(){return r.asm.Ao.apply(null,arguments)};r._sk_path_arc_to_with_oval=function(){return r.asm.Bo.apply(null,arguments)};r._sk_path_arc_to_with_points=function(){return r.asm.Co.apply(null,arguments)}; +r._sk_path_clone=function(){return r.asm.Do.apply(null,arguments)};r._sk_path_close=function(){return r.asm.Eo.apply(null,arguments)};r._sk_path_compute_tight_bounds=function(){return r.asm.Fo.apply(null,arguments)};r._sk_path_conic_to=function(){return r.asm.Go.apply(null,arguments)};r._sk_path_contains=function(){return r.asm.Ho.apply(null,arguments)};r._sk_path_convert_conic_to_quads=function(){return r.asm.Io.apply(null,arguments)}; +r._sk_path_count_points=function(){return r.asm.Jo.apply(null,arguments)};r._sk_path_count_verbs=function(){return r.asm.Ko.apply(null,arguments)};r._sk_path_create_iter=function(){return r.asm.Lo.apply(null,arguments)};r._sk_path_create_rawiter=function(){return r.asm.Mo.apply(null,arguments)};r._sk_path_cubic_to=function(){return r.asm.No.apply(null,arguments)};r._sk_path_delete=function(){return r.asm.Oo.apply(null,arguments)}; +r._sk_path_effect_create_1d_path=function(){return r.asm.Po.apply(null,arguments)};r._sk_path_effect_create_2d_line=function(){return r.asm.Qo.apply(null,arguments)};r._sk_path_effect_create_2d_path=function(){return r.asm.Ro.apply(null,arguments)};r._sk_path_effect_create_compose=function(){return r.asm.So.apply(null,arguments)};r._sk_path_effect_create_corner=function(){return r.asm.To.apply(null,arguments)};r._sk_path_effect_create_dash=function(){return r.asm.Uo.apply(null,arguments)}; +r._sk_path_effect_create_discrete=function(){return r.asm.Vo.apply(null,arguments)};r._sk_path_effect_create_sum=function(){return r.asm.Wo.apply(null,arguments)};r._sk_path_effect_create_trim=function(){return r.asm.Xo.apply(null,arguments)};r._sk_path_effect_unref=function(){return r.asm.Yo.apply(null,arguments)};r._sk_path_get_bounds=function(){return r.asm.Zo.apply(null,arguments)};r._sk_path_get_convexity=function(){return r.asm._o.apply(null,arguments)}; +r._sk_path_get_filltype=function(){return r.asm.$o.apply(null,arguments)};r._sk_path_get_last_point=function(){return r.asm.ap.apply(null,arguments)};r._sk_path_get_point=function(){return r.asm.bp.apply(null,arguments)};r._sk_path_get_points=function(){return r.asm.cp.apply(null,arguments)};r._sk_path_get_segment_masks=function(){return r.asm.dp.apply(null,arguments)};r._sk_path_is_line=function(){return r.asm.ep.apply(null,arguments)};r._sk_path_is_oval=function(){return r.asm.fp.apply(null,arguments)}; +r._sk_path_is_rect=function(){return r.asm.gp.apply(null,arguments)};r._sk_path_is_rrect=function(){return r.asm.hp.apply(null,arguments)};r._sk_path_iter_conic_weight=function(){return r.asm.ip.apply(null,arguments)};r._sk_path_iter_destroy=function(){return r.asm.jp.apply(null,arguments)};r._sk_path_iter_is_close_line=function(){return r.asm.kp.apply(null,arguments)};r._sk_path_iter_is_closed_contour=function(){return r.asm.lp.apply(null,arguments)}; +r._sk_path_iter_next=function(){return r.asm.mp.apply(null,arguments)};r._sk_path_line_to=function(){return r.asm.np.apply(null,arguments)};r._sk_path_move_to=function(){return r.asm.op.apply(null,arguments)};r._sk_path_new=function(){return r.asm.pp.apply(null,arguments)};r._sk_path_parse_svg_string=function(){return r.asm.qp.apply(null,arguments)};r._sk_path_quad_to=function(){return r.asm.rp.apply(null,arguments)};r._sk_path_rarc_to=function(){return r.asm.sp.apply(null,arguments)}; +r._sk_path_rawiter_conic_weight=function(){return r.asm.tp.apply(null,arguments)};r._sk_path_rawiter_destroy=function(){return r.asm.up.apply(null,arguments)};r._sk_path_rawiter_next=function(){return r.asm.vp.apply(null,arguments)};r._sk_path_rawiter_peek=function(){return r.asm.wp.apply(null,arguments)};r._sk_path_rconic_to=function(){return r.asm.xp.apply(null,arguments)};r._sk_path_rcubic_to=function(){return r.asm.yp.apply(null,arguments)}; +r._sk_path_reset=function(){return r.asm.zp.apply(null,arguments)};r._sk_path_rewind=function(){return r.asm.Ap.apply(null,arguments)};r._sk_path_rline_to=function(){return r.asm.Bp.apply(null,arguments)};r._sk_path_rmove_to=function(){return r.asm.Cp.apply(null,arguments)};r._sk_path_rquad_to=function(){return r.asm.Dp.apply(null,arguments)};r._sk_path_set_convexity=function(){return r.asm.Ep.apply(null,arguments)};r._sk_path_set_filltype=function(){return r.asm.Fp.apply(null,arguments)}; +r._sk_path_to_svg_string=function(){return r.asm.Gp.apply(null,arguments)};r._sk_path_transform=function(){return r.asm.Hp.apply(null,arguments)};r._sk_pathmeasure_destroy=function(){return r.asm.Ip.apply(null,arguments)};r._sk_pathmeasure_get_length=function(){return r.asm.Jp.apply(null,arguments)};r._sk_pathmeasure_get_matrix=function(){return r.asm.Kp.apply(null,arguments)};r._sk_pathmeasure_get_pos_tan=function(){return r.asm.Lp.apply(null,arguments)}; +r._sk_pathmeasure_get_segment=function(){return r.asm.Mp.apply(null,arguments)};r._sk_pathmeasure_is_closed=function(){return r.asm.Np.apply(null,arguments)};r._sk_pathmeasure_new=function(){return r.asm.Op.apply(null,arguments)};r._sk_pathmeasure_new_with_path=function(){return r.asm.Pp.apply(null,arguments)};r._sk_pathmeasure_next_contour=function(){return r.asm.Qp.apply(null,arguments)};r._sk_pathmeasure_set_path=function(){return r.asm.Rp.apply(null,arguments)}; +r._sk_pathop_op=function(){return r.asm.Sp.apply(null,arguments)};r._sk_pathop_simplify=function(){return r.asm.Tp.apply(null,arguments)};r._sk_pathop_tight_bounds=function(){return r.asm.Up.apply(null,arguments)};r._sk_shader_new_bitmap=function(){return r.asm.Vp.apply(null,arguments)};r._sk_shader_new_color=function(){return r.asm.Wp.apply(null,arguments)};r._sk_shader_new_color_filter=function(){return r.asm.Xp.apply(null,arguments)}; +r._sk_shader_new_compose=function(){return r.asm.Yp.apply(null,arguments)};r._sk_shader_new_compose_with_mode=function(){return r.asm.Zp.apply(null,arguments)};r._sk_shader_new_empty=function(){return r.asm._p.apply(null,arguments)};r._sk_shader_new_linear_gradient=function(){return r.asm.$p.apply(null,arguments)};r._sk_shader_new_local_matrix=function(){return r.asm.aq.apply(null,arguments)};r._sk_shader_new_perlin_noise_fractal_noise=function(){return r.asm.bq.apply(null,arguments)}; +r._sk_shader_new_perlin_noise_turbulence=function(){return r.asm.cq.apply(null,arguments)};r._sk_shader_new_radial_gradient=function(){return r.asm.dq.apply(null,arguments)};r._sk_shader_new_sweep_gradient=function(){return r.asm.eq.apply(null,arguments)};r._sk_shader_new_two_point_conical_gradient=function(){return r.asm.fq.apply(null,arguments)};r._sk_shader_unref=function(){return r.asm.gq.apply(null,arguments)};r._sk_string_destructor=function(){return r.asm.hq.apply(null,arguments)}; +r._sk_string_get_c_str=function(){return r.asm.iq.apply(null,arguments)};r._sk_string_get_size=function(){return r.asm.jq.apply(null,arguments)};r._sk_string_new_empty=function(){return r.asm.kq.apply(null,arguments)};r._sk_string_new_with_copy=function(){return r.asm.lq.apply(null,arguments)};r._sk_surface_draw=function(){return r.asm.mq.apply(null,arguments)};r._sk_surface_get_canvas=function(){return r.asm.nq.apply(null,arguments)}; +r._sk_surface_get_props=function(){return r.asm.oq.apply(null,arguments)};r._sk_surface_new_backend_render_target=function(){return r.asm.pq.apply(null,arguments)};r._sk_surface_new_backend_texture=function(){return r.asm.qq.apply(null,arguments)};r._sk_surface_new_backend_texture_as_render_target=function(){return r.asm.rq.apply(null,arguments)};r._sk_surface_new_image_snapshot=function(){return r.asm.sq.apply(null,arguments)};r._sk_surface_new_null=function(){return r.asm.tq.apply(null,arguments)}; +r._sk_surface_new_raster=function(){return r.asm.uq.apply(null,arguments)};r._sk_surface_new_raster_direct=function(){return r.asm.vq.apply(null,arguments)};r._sk_surface_new_render_target=function(){return r.asm.wq.apply(null,arguments)};r._sk_surface_peek_pixels=function(){return r.asm.xq.apply(null,arguments)};r._sk_surface_read_pixels=function(){return r.asm.yq.apply(null,arguments)};r._sk_surface_unref=function(){return r.asm.zq.apply(null,arguments)}; +r._sk_surfaceprops_delete=function(){return r.asm.Aq.apply(null,arguments)};r._sk_surfaceprops_get_flags=function(){return r.asm.Bq.apply(null,arguments)};r._sk_surfaceprops_get_pixel_geometry=function(){return r.asm.Cq.apply(null,arguments)};r._sk_surfaceprops_new=function(){return r.asm.Dq.apply(null,arguments)};r._sk_typeface_chars_to_glyphs=function(){return r.asm.Eq.apply(null,arguments)};r._sk_typeface_count_tables=function(){return r.asm.Fq.apply(null,arguments)}; +r._sk_typeface_create_default=function(){return r.asm.Gq.apply(null,arguments)};r._sk_typeface_create_from_file=function(){return r.asm.Hq.apply(null,arguments)};r._sk_typeface_create_from_name_with_font_style=function(){return r.asm.Iq.apply(null,arguments)};r._sk_typeface_create_from_stream=function(){return r.asm.Jq.apply(null,arguments)};r._sk_typeface_get_family_name=function(){return r.asm.Kq.apply(null,arguments)};r._sk_typeface_get_font_slant=function(){return r.asm.Lq.apply(null,arguments)}; +r._sk_typeface_get_font_weight=function(){return r.asm.Mq.apply(null,arguments)};r._sk_typeface_get_font_width=function(){return r.asm.Nq.apply(null,arguments)};r._sk_typeface_get_fontstyle=function(){return r.asm.Oq.apply(null,arguments)};r._sk_typeface_get_table_data=function(){return r.asm.Pq.apply(null,arguments)};r._sk_typeface_get_table_size=function(){return r.asm.Qq.apply(null,arguments)};r._sk_typeface_get_table_tags=function(){return r.asm.Rq.apply(null,arguments)}; +r._sk_typeface_get_units_per_em=function(){return r.asm.Sq.apply(null,arguments)};r._sk_typeface_open_stream=function(){return r.asm.Tq.apply(null,arguments)};r._sk_typeface_ref_default=function(){return r.asm.Uq.apply(null,arguments)};r._sk_typeface_unref=function(){return r.asm.Vq.apply(null,arguments)};r._sk_vertices_make_copy=function(){return r.asm.Wq.apply(null,arguments)};r._sk_vertices_unref=function(){return r.asm.Xq.apply(null,arguments)}; +var sa=r.stackAlloc=function(){return r.asm.ws.apply(null,arguments)},F=r.stackRestore=function(){return r.asm.xs.apply(null,arguments)},D=r.stackSave=function(){return r.asm.ys.apply(null,arguments)};r.dynCall_di=function(){return r.asm.Yq.apply(null,arguments)};r.dynCall_fi=function(){return r.asm.Zq.apply(null,arguments)};r.dynCall_fif=function(){return r.asm._q.apply(null,arguments)};r.dynCall_fiff=function(){return r.asm.$q.apply(null,arguments)}; +r.dynCall_fii=function(){return r.asm.ar.apply(null,arguments)};r.dynCall_fiifi=function(){return r.asm.br.apply(null,arguments)};var Vd=r.dynCall_i=function(){return r.asm.cr.apply(null,arguments)},Wd=r.dynCall_ii=function(){return r.asm.dr.apply(null,arguments)};r.dynCall_iidi=function(){return r.asm.er.apply(null,arguments)};r.dynCall_iif=function(){return r.asm.fr.apply(null,arguments)};r.dynCall_iiffi=function(){return r.asm.gr.apply(null,arguments)}; +var Xd=r.dynCall_iii=function(){return r.asm.hr.apply(null,arguments)},Yd=r.dynCall_iiii=function(){return r.asm.ir.apply(null,arguments)};r.dynCall_iiiif=function(){return r.asm.jr.apply(null,arguments)};var Zd=r.dynCall_iiiii=function(){return r.asm.kr.apply(null,arguments)};r.dynCall_iiiiid=function(){return r.asm.lr.apply(null,arguments)};r.dynCall_iiiiii=function(){return r.asm.mr.apply(null,arguments)};r.dynCall_iiiiiid=function(){return r.asm.nr.apply(null,arguments)}; +r.dynCall_iiiiiii=function(){return r.asm.or.apply(null,arguments)};r.dynCall_iiiiiiii=function(){return r.asm.pr.apply(null,arguments)};r.dynCall_iiiiiiiii=function(){return r.asm.qr.apply(null,arguments)};r.dynCall_iiiiiiiiii=function(){return r.asm.rr.apply(null,arguments)};r.dynCall_iiiiiiiiiii=function(){return r.asm.sr.apply(null,arguments)};r.dynCall_iiiiij=function(){return r.asm.tr.apply(null,arguments)};r.dynCall_iiiij=function(){return r.asm.ur.apply(null,arguments)}; +r.dynCall_iiij=function(){return r.asm.vr.apply(null,arguments)};r.dynCall_iijj=function(){return r.asm.wr.apply(null,arguments)};r.dynCall_ji=function(){return r.asm.xr.apply(null,arguments)};r.dynCall_jii=function(){return r.asm.yr.apply(null,arguments)};r.dynCall_jiiiijiiiii=function(){return r.asm.zr.apply(null,arguments)};var $d=r.dynCall_v=function(){return r.asm.Ar.apply(null,arguments)};r.dynCall_vf=function(){return r.asm.Br.apply(null,arguments)}; +r.dynCall_vff=function(){return r.asm.Cr.apply(null,arguments)};r.dynCall_vffff=function(){return r.asm.Dr.apply(null,arguments)};r.dynCall_vfi=function(){return r.asm.Er.apply(null,arguments)};var ae=r.dynCall_vi=function(){return r.asm.Fr.apply(null,arguments)};r.dynCall_vif=function(){return r.asm.Gr.apply(null,arguments)};r.dynCall_viff=function(){return r.asm.Hr.apply(null,arguments)};r.dynCall_vifff=function(){return r.asm.Ir.apply(null,arguments)}; +r.dynCall_viffff=function(){return r.asm.Jr.apply(null,arguments)};r.dynCall_vifffff=function(){return r.asm.Kr.apply(null,arguments)};r.dynCall_viffffff=function(){return r.asm.Lr.apply(null,arguments)};r.dynCall_vifffffffff=function(){return r.asm.Mr.apply(null,arguments)};r.dynCall_viffi=function(){return r.asm.Nr.apply(null,arguments)};r.dynCall_vifii=function(){return r.asm.Or.apply(null,arguments)};var be=r.dynCall_vii=function(){return r.asm.Pr.apply(null,arguments)}; +r.dynCall_viid=function(){return r.asm.Qr.apply(null,arguments)};r.dynCall_viif=function(){return r.asm.Rr.apply(null,arguments)};r.dynCall_viifd=function(){return r.asm.Sr.apply(null,arguments)};r.dynCall_viiff=function(){return r.asm.Tr.apply(null,arguments)};r.dynCall_viifff=function(){return r.asm.Ur.apply(null,arguments)};r.dynCall_viiffff=function(){return r.asm.Vr.apply(null,arguments)};r.dynCall_viifffff=function(){return r.asm.Wr.apply(null,arguments)}; +r.dynCall_viiffffff=function(){return r.asm.Xr.apply(null,arguments)};r.dynCall_viifffffffff=function(){return r.asm.Yr.apply(null,arguments)};r.dynCall_viiffi=function(){return r.asm.Zr.apply(null,arguments)};r.dynCall_viiffii=function(){return r.asm._r.apply(null,arguments)};var ce=r.dynCall_viii=function(){return r.asm.$r.apply(null,arguments)};r.dynCall_viiif=function(){return r.asm.as.apply(null,arguments)};r.dynCall_viiifffffffff=function(){return r.asm.bs.apply(null,arguments)}; +r.dynCall_viiiffi=function(){return r.asm.cs.apply(null,arguments)};var de=r.dynCall_viiii=function(){return r.asm.ds.apply(null,arguments)};r.dynCall_viiiifi=function(){return r.asm.es.apply(null,arguments)};var ee=r.dynCall_viiiii=function(){return r.asm.fs.apply(null,arguments)};r.dynCall_viiiiif=function(){return r.asm.gs.apply(null,arguments)};r.dynCall_viiiiiffii=function(){return r.asm.hs.apply(null,arguments)};r.dynCall_viiiiii=function(){return r.asm.is.apply(null,arguments)}; +r.dynCall_viiiiiii=function(){return r.asm.js.apply(null,arguments)};r.dynCall_viiiiiiii=function(){return r.asm.ks.apply(null,arguments)};var fe=r.dynCall_viiiiiiiii=function(){return r.asm.ls.apply(null,arguments)};r.dynCall_viiiiiiiiii=function(){return r.asm.ms.apply(null,arguments)};r.dynCall_viiiiiiiiiii=function(){return r.asm.ns.apply(null,arguments)};r.dynCall_viiiiiiiiiiii=function(){return r.asm.os.apply(null,arguments)}; +r.dynCall_viiiiiiiiiiiiiii=function(){return r.asm.ps.apply(null,arguments)};r.dynCall_viiiij=function(){return r.asm.qs.apply(null,arguments)};r.dynCall_viiij=function(){return r.asm.rs.apply(null,arguments)};r.dynCall_viij=function(){return r.asm.ss.apply(null,arguments)};r.dynCall_viijii=function(){return r.asm.ts.apply(null,arguments)};r.dynCall_vij=function(){return r.asm.us.apply(null,arguments)};r.dynCall_vji=function(){return r.asm.vs.apply(null,arguments)};r.asm=ke;r.ccall=ra; +r.cwrap=function(a,b,d,e){d=d||[];var f=d.every(function(a){return"number"===a});return"string"!==b&&f&&!e?qa(a):function(){return ra(a,b,d,arguments,e)}}; +r.setValue=function(a,b,d){d=d||"i8";"*"===d.charAt(d.length-1)&&(d="i32");switch(d){case "i1":C[a>>0]=b;break;case "i8":C[a>>0]=b;break;case "i16":J[a>>1]=b;break;case "i32":G[a>>2]=b;break;case "i64":c=[b>>>0,(h=b,1<=+Na(h)?0>>0:~~+Oa((h-+(~~h>>>0))/4294967296)>>>0:0)];G[a>>2]=c[0];G[a+4>>2]=c[1];break;case "float":L[a>>2]=b;break;case "double":Da[a>>3]=b;break;default:v("invalid type for setValue: "+d)}}; +r.getValue=function(a,b){b=b||"i8";"*"===b.charAt(b.length-1)&&(b="i32");switch(b){case "i1":return C[a>>0];case "i8":return C[a>>0];case "i16":return J[a>>1];case "i32":return G[a>>2];case "i64":return G[a>>2];case "float":return L[a>>2];case "double":return Da[a>>3];default:v("invalid type for getValue: "+b)}return null};r.UTF8ToString=E;r.stringToUTF8=B;r.lengthBytesUTF8=za; +r.UTF16ToString=function(a){var b;for(b=a>>1;J[b];)++b;b<<=1;if(32>1];if(0==e)return d;++b;d+=String.fromCharCode(e)}};r.stringToUTF16=function(a,b,d){void 0===d&&(d=2147483647);if(2>d)return 0;d-=2;var e=b;d=d<2*a.length?d/2:a.length;for(var f=0;f>1]=a.charCodeAt(f),b+=2;J[b>>1]=0;return b-e};r.lengthBytesUTF16=function(a){return 2*a.length}; +r.addFunction=function(a){for(var b=0;20>b;b++)if(!z[b])return z[b]=a,1+b;throw"Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";};r.removeFunction=function(a){z[a-1]=null};r.then=function(a){if(r.calledRun)a(r);else{var b=r.onRuntimeInitialized;r.onRuntimeInitialized=function(){b&&b();a(r)}}return r};function ja(a){this.name="ExitStatus";this.message="Program terminated with exit("+a+")";this.status=a}ja.prototype=Error();ja.prototype.constructor=ja; +Ua=function le(){r.calledRun||me();r.calledRun||(Ua=le)}; +function me(){function a(){if(!r.calledRun&&(r.calledRun=!0,!A)){La||(La=!0,r.noFSInit||jc||(jc=!0,ic(),r.stdin=r.stdin,r.stdout=r.stdout,r.stderr=r.stderr,r.stdin?lc("stdin",r.stdin):cc("/dev/tty","/dev/stdin"),r.stdout?lc("stdout",null,r.stdout):cc("/dev/tty","/dev/stdout"),r.stderr?lc("stderr",null,r.stderr):cc("/dev/tty1","/dev/stderr"),dc("/dev/stdin","r"),dc("/dev/stdout","w"),dc("/dev/stderr","w")),Ga(Ia));Jb=!1;Ga(Ja);if(r.onRuntimeInitialized)r.onRuntimeInitialized();if(r.postRun)for("function"== +typeof r.postRun&&(r.postRun=[r.postRun]);r.postRun.length;){var a=r.postRun.shift();Ka.unshift(a)}Ga(Ka)}}if(!(0 + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + diff --git a/dis/VSTemplate/WebAsm/server.py b/dis/VSTemplate/WebAsm/server.py new file mode 100644 index 000000000..15948ab05 --- /dev/null +++ b/dis/VSTemplate/WebAsm/server.py @@ -0,0 +1,36 @@ +import sys + +if sys.version_info[0] == 2: + + import SimpleHTTPServer + import SocketServer + + PORT = 8000 + + class Handler(SimpleHTTPServer.SimpleHTTPRequestHandler): + pass + + Handler.extensions_map['.wasm'] = 'application/wasm' + + httpd = SocketServer.TCPServer(("", PORT), Handler) + + print ("python 2 serving at port", PORT) + httpd.serve_forever() + + +if sys.version_info[0] == 3: + + + import http.server + import socketserver + + PORT = 8000 + + Handler = http.server.SimpleHTTPRequestHandler + Handler.extensions_map['.wasm'] = 'application/wasm' + Handler.extensions_map['.js'] = 'text/javascript' + + with socketserver.TCPServer(("", PORT), Handler) as httpd: + print("python 3 serving at port", PORT) + httpd.serve_forever() + diff --git a/dis/VSTemplate/__PreviewImage.png b/dis/VSTemplate/__PreviewImage.png new file mode 100644 index 000000000..a6d3d4f28 Binary files /dev/null and b/dis/VSTemplate/__PreviewImage.png differ diff --git a/dis/VSTemplate/__TemplateIcon.ico b/dis/VSTemplate/__TemplateIcon.ico new file mode 100644 index 000000000..2f649cf97 Binary files /dev/null and b/dis/VSTemplate/__TemplateIcon.ico differ