public virtual void DrawInSurface(SKSurface surface, GRBackendRenderTarget renderTarget)
{
if (PaintSurface != null)
{
PaintSurface.Invoke(this, new SKPaintGLSurfaceEventArgs(surface, renderTarget));
}
}
private void ResizeScreen()
{
_skScreenSurface?.Dispose();
_skScreenSurface = null;
_skScreenRenderTarget?.Dispose();
_skScreenRenderTarget = null;
var screenRenderTargetInfo = new GRGlFramebufferInfo()
{
Format = (int)PixelInternalFormat.Rgba8,
FramebufferObjectId = 0,
};
var screenSize = _tkWindow.ClientSize;
_skScreenRenderTarget = new GRBackendRenderTarget(screenSize.Width, screenSize.Height, 1, 0, screenRenderTargetInfo);
if (_skScreenRenderTarget == null)
{
throw new Exception($"Failed to create SkiaSharp screen render target.");
}
_skScreenSurface = SKSurface.Create(_skContext, _skScreenRenderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
if (_skScreenSurface == null)
{
throw new Exception($"Failed to create SkiaSharp screen surface.");
}
foreach (var caption in _captions)
{
caption.Lines = null;
}
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
// create the contexts if not done already
if (grContext == null)
{
var glInterface = GRGlInterface.CreateNativeGlInterface();
grContext = GRContext.Create(GRBackend.OpenGL, glInterface);
// get initial details
renderTarget = CreateRenderTarget();
}
// update to the latest dimensions
renderTarget = new GRBackendRenderTarget(Width, Height, renderTarget.SampleCount, renderTarget.StencilBits, renderTarget.GetGlFramebufferInfo());
// create the surface
using (var surface = SKSurface.Create(grContext, renderTarget, SKColorType.Rgba8888))
{
if (PaintSurface != null)
{
PaintSurface.Invoke(surface);
}
// start drawing
OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget));
surface.Canvas.Flush();
}
// update the control
SwapBuffers();
}
protected override void OnRenderFrame(Rect rect)
{
// clear everything
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// create the SkiaSharp context
if (context == null)
{
glInterface = GRGlInterface.CreateNativeAngleInterface();
context = GRContext.Create(GRBackend.OpenGL, glInterface);
}
// manage the drawing surface
if (renderTarget == null || surface == null || renderTarget.Width != (int)rect.Width || renderTarget.Height != (int)rect.Height)
{
// create or update the dimensions
renderTarget?.Dispose();
renderTarget = SKGLDrawable.CreateRenderTarget((int)rect.Width, (int)rect.Height);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
}
using (new SKAutoCanvasRestore(surface.Canvas, true))
{
// start drawing
OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888));
}
// update the control
surface.Canvas.Flush();
context.Flush();
}
protected override void OnRenderFrame(Rect rect)
{
// clear everything
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// create the SkiaSharp context
if (context == null)
{
glInterface = GRGlInterface.Create();
context = GRContext.CreateGl(glInterface);
}
// get the new surface size
var newSize = new SKSizeI((int)rect.Width, (int)rect.Height);
// manage the drawing surface
if (renderTarget == null || lastSize != newSize || !renderTarget.IsValid)
{
// create or update the dimensions
lastSize = newSize;
// read the info from the buffer
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
Gles.glGetIntegerv(Gles.GL_SAMPLES, out var samples);
var maxSamples = context.GetMaxSurfaceSampleCount(colorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
// destroy the old surface
surface?.Dispose();
surface = null;
canvas = null;
// re-create the render target
renderTarget?.Dispose();
renderTarget = new GRBackendRenderTarget(newSize.Width, newSize.Height, samples, stencil, glInfo);
}
// create the surface
if (surface == null)
{
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
canvas = surface.Canvas;
}
using (new SKAutoCanvasRestore(canvas, true))
{
// start drawing
OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType, glInfo));
}
// update the control
canvas.Flush();
context.Flush();
}
protected sealed override void CreateDrawingSurface()
{
if (glSurface == IntPtr.Zero)
{
// create the surface
glSurface = Evas.evas_gl_surface_create(glEvas, glConfigPtr, surfaceSize.Width, surfaceSize.Height);
// copy the native surface to the image
Evas.evas_gl_native_surface_get(glEvas, glSurface, out var nativeSurface);
Evas.evas_object_image_native_surface_set(evasImage, ref nativeSurface);
// switch to the current OpenGL context
Evas.evas_gl_make_current(glEvas, glSurface, glContext);
// resize the viewport
Gles.glViewport(0, 0, surfaceSize.Width, surfaceSize.Height);
// create the interface using the function pointers provided by the EFL
var glInterface = GRGlInterface.CreateNativeEvasInterface(glEvas);
context?.Dispose();
context = GRContext.Create(GRBackend.OpenGL, glInterface);
// create the render target
renderTarget?.Dispose();
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
var glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget(surfaceSize.Width, surfaceSize.Height, context.GetMaxSurfaceSampleCount(colorType), stencil, glInfo);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
}
}
protected override void OnLoad(EventArgs ee)
{
base.OnLoad(ee);
var glInterface = GRGlInterface.CreateNativeGlInterface();
Debug.Assert(glInterface.Validate());
this._context = GRContext.Create(GRBackend.OpenGL, glInterface);
Debug.Assert(this._context.Handle != IntPtr.Zero);
this._renderTarget = CreateRenderTarget(_context);
this.KeyDown += (o, e) =>
{
if (e.Key == Key.Escape)
{
this.Close();
}
};
FocusedChanged += OnFocusedChanged;
InitMouse();
// WindowState = WindowState.Fullscreen;
CursorVisible = false;
this.CursorVisible = true;
}
protected sealed override void CreateDrawingSurface()
{
if (glSurface == IntPtr.Zero)
{
// create the surface
glSurface = Evas.evas_gl_surface_create(glEvas, glConfigPtr, surfaceSize.Width, surfaceSize.Height);
// copy the native surface to the image
Evas.evas_gl_native_surface_get(glEvas, glSurface, out var nativeSurface);
Evas.evas_object_image_native_surface_set(evasImage, ref nativeSurface);
// switch to the current OpenGL context
Evas.evas_gl_make_current(glEvas, glSurface, glContext);
// resize the viewport
Gles.glViewport(0, 0, surfaceSize.Width, surfaceSize.Height);
// create the interface using the function pointers provided by the EFL
var glInterface = GRGlInterface.CreateNativeEvasInterface(glEvas);
context?.Dispose();
context = GRContext.Create(GRBackend.OpenGL, glInterface);
// create the render target
renderTarget?.Dispose();
renderTarget = SKGLDrawable.CreateRenderTarget(surfaceSize.Width, surfaceSize.Height);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, GRSurfaceOrigin.BottomLeft, SKImageInfo.PlatformColorType);
}
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTarget renderTarget, GRSurfaceOrigin origin, SKColorType colorType)
{
Surface = surface;
BackendRenderTarget = renderTarget;
ColorType = colorType;
Origin = origin;
}
private void glControl1_Paint(object sender, PaintEventArgs e)
{
Control senderControl = (Control)sender;
if (context == null)
{
var glInterface = GRGlInterface.CreateNativeGlInterface();
context = GRContext.Create(GRBackend.OpenGL, glInterface);
}
if (renderTarget == null || surface == null || renderTarget.Width != senderControl.Width || renderTarget.Height != senderControl.Height)
{
renderTarget?.Dispose();
GL.GetInteger(GetPName.FramebufferBinding, out var framebuffer);
GL.GetInteger(GetPName.StencilBits, out var stencil);
var glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget(senderControl.Width, senderControl.Height, context.GetMaxSurfaceSampleCount(colorType), stencil, glInfo);
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
}
figure.Render(surface.Canvas, figureSize, plotEngagedWithMouse);
surface.Canvas.Flush();
glControl1.SwapBuffers();
}
private void InitSkia()
{
if (grContext == null)
{
var glInterface = GRGlInterface.Create();
grContext = GRContext.CreateGl(glInterface);
}
// define the surface properties
// create or update the dimensions
renderTarget?.Dispose();
GL.GetInteger(GetPName.FramebufferBinding, out var framebuffer);
var stencil = 0;
GL.GetInteger(GetPName.Samples, out var samples);
var maxSamples = grContext.GetMaxSurfaceSampleCount(ColorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
var glInfo = new GRGlFramebufferInfo((uint)framebuffer, ColorType.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget(CurrentSize.X, CurrentSize.Y, 0, 0, glInfo);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(grContext, renderTarget, SurfaceOrigin, ColorType);
Paint = new SKPaint {
Color = new SKColor(0, 128, 0), IsAntialias = true
};
}
private SKSurface GenerateSkiaSurface(GRContext skiaContext, Size surfaceSize)
{
var frameBufferInfo = new GRGlFramebufferInfo((uint)new UIntPtr(0), GRPixelConfig.Rgba8888.ToGlSizedFormat());
var backendRenderTarget = new GRBackendRenderTarget(surfaceSize.Width, surfaceSize.Height, 0, 8, frameBufferInfo);
return(SKSurface.Create(skiaContext, backendRenderTarget, GRSurfaceOrigin.BottomLeft, SKImageInfo.PlatformColorType));
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTargetDesc renderTarget)
{
Surface = surface;
rtDesc = renderTarget;
BackendRenderTarget = new GRBackendRenderTarget(GRBackend.OpenGL, renderTarget);
ColorType = renderTarget.Config.ToColorType();
Origin = renderTarget.Origin;
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTarget renderTarget, GRSurfaceOrigin origin, SKImageInfo info, SKImageInfo rawInfo)
{
Surface = surface;
BackendRenderTarget = renderTarget;
ColorType = info.ColorType;
Origin = origin;
Info = info;
RawInfo = rawInfo;
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTarget renderTarget, GRSurfaceOrigin origin, SKColorType colorType)
{
Surface = surface;
BackendRenderTarget = renderTarget;
ColorType = colorType;
Origin = origin;
Info = new SKImageInfo(renderTarget.Width, renderTarget.Height, ColorType);
RawInfo = Info;
}
internal void RenderFrame()
{
if (!jsInfo.IsValid)
{
return;
}
// create the SkiaSharp context
if (context == null)
{
glInterface = GRGlInterface.Create();
context = GRContext.CreateGl(glInterface);
// bump the default resource cache limit
context.SetResourceCacheLimit(ResourceCacheBytes);
}
// get the new surface size
var newSize = new SKSizeI((int)(ActualWidth * ContentsScale), (int)(ActualHeight * ContentsScale));
// manage the drawing surface
if (renderTarget == null || lastSize != newSize || !renderTarget.IsValid)
{
// create or update the dimensions
lastSize = newSize;
glInfo = new GRGlFramebufferInfo(jsInfo.FboId, colorType.ToGlSizedFormat());
// destroy the old surface
surface?.Dispose();
surface = null;
canvas = null;
// re-create the render target
renderTarget?.Dispose();
renderTarget = new GRBackendRenderTarget(newSize.Width, newSize.Height, jsInfo.Samples, jsInfo.Stencil, glInfo);
}
// create the surface
if (surface == null)
{
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
canvas = surface.Canvas;
}
using (new SKAutoCanvasRestore(canvas, true))
{
// start drawing
#pragma warning disable CS0612 // Type or member is obsolete
OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType, glInfo));
#pragma warning restore CS0612 // Type or member is obsolete
}
// update the control
canvas.Flush();
context.Flush();
}
private void FreeContext()
{
surface?.Dispose();
surface = null;
renderTarget?.Dispose();
renderTarget = null;
context?.Dispose();
context = null;
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// create the render target
if (renderTarget == null || lastSize != newSize || !renderTarget.IsValid)
{
// create or update the dimensions
lastSize = newSize;
// read the info from the buffer
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
Gles.glGetIntegerv(Gles.GL_SAMPLES, out var samples);
var maxSamples = context.GetMaxSurfaceSampleCount(colorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
// destroy the old surface
surface?.Dispose();
surface = null;
canvas = null;
// re-create the render target
renderTarget?.Dispose();
renderTarget = new GRBackendRenderTarget(newSize.Width, newSize.Height, samples, stencil, glInfo);
}
// create the surface
if (surface == null)
{
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
canvas = surface.Canvas;
}
using (new SKAutoCanvasRestore(canvas, true))
{
// start drawing
var e = new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType, glInfo);
#pragma warning disable CS0618 // Type or member is obsolete
DrawInSurface(e.Surface, e.RenderTarget);
#pragma warning restore CS0618 // Type or member is obsolete
OnPaintSurface(e);
}
// flush the SkiaSharp contents to GL
canvas.Flush();
context.Flush();
OpenGLContext.FlushBuffer();
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTarget renderTarget, GRSurfaceOrigin origin, SKColorType colorType, GRGlFramebufferInfo glInfo)
{
Surface = surface;
BackendRenderTarget = renderTarget;
ColorType = colorType;
Origin = origin;
rtDesc = CreateDesc(glInfo);
Info = new SKImageInfo(renderTarget.Width, renderTarget.Height, colorType);
RawInfo = Info;
}
public BlazorSkiaGpuRenderSession(BlazorSkiaSurface blazorSkiaSurface, GRBackendRenderTarget renderTarget)
{
_surface = SKSurface.Create(blazorSkiaSurface.Context, renderTarget, blazorSkiaSurface.Origin, blazorSkiaSurface.ColorType);
GrContext = blazorSkiaSurface.Context;
ScaleFactor = blazorSkiaSurface.Scaling;
SurfaceOrigin = blazorSkiaSurface.Origin;
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTarget renderTarget, GRSurfaceOrigin origin, SKColorType colorType, GRGlFramebufferInfo glInfo)
{
Surface = surface;
BackendRenderTarget = renderTarget;
ColorType = colorType;
Origin = origin;
#pragma warning disable CS0612 // Type or member is obsolete
rtDesc = CreateDesc(glInfo);
#pragma warning restore CS0612 // Type or member is obsolete
}
public GlGpuSession(GRContext grContext,
GRBackendRenderTarget backendRenderTarget,
SKSurface surface,
IGlPlatformSurfaceRenderingSession glSession)
{
GrContext = grContext;
_backendRenderTarget = backendRenderTarget;
_surface = surface;
_glSession = glSession;
}
public SKPaintGLSurfaceEventArgs(SKSurface surface, GRBackendRenderTargetDesc renderTarget)
{
Surface = surface;
rtDesc = renderTarget;
BackendRenderTarget = new GRBackendRenderTarget(GRBackend.OpenGL, renderTarget);
ColorType = renderTarget.Config.ToColorType();
Origin = renderTarget.Origin;
Info = new SKImageInfo(renderTarget.Width, renderTarget.Height, ColorType);
RawInfo = Info;
}
public void PaintTextGL(object sender, SKSurface surface, GRBackendRenderTarget backendRenderTarget)
{
float dx = -10;
float dy = 10;
float sigmaX = 3;
float sigmaY = 3;
var Bind = sender as Xamarin.Forms.View;
string text = (string)Bind.BindingContext;
var canvas = surface.Canvas;
canvas.Clear();
using (SKPaint textPaintFill = new SKPaint
{
Style = SKPaintStyle.Fill,
IsAntialias = true,
Color = SKColor.Parse("#E7D014")
})
{
using (SKPaint textPaint = new SKPaint
{
Style = SKPaintStyle.Stroke,
StrokeWidth = 4,
IsAntialias = true,
Color = SKColor.Parse("#000")
})
{
textPaintFill.Typeface = GetTypeface("AmericanCaptain.ttf");
textPaint.Typeface = textPaintFill.Typeface;
float textWidth = textPaintFill.MeasureText(text);
textPaintFill.TextSize = 0.85f * backendRenderTarget.Width * textPaintFill.TextSize / textWidth;
textPaint.TextSize = 0.85f * backendRenderTarget.Width * textPaint.TextSize / textWidth;
SKRect textBounds = new SKRect();
textPaint.MeasureText(text, ref textBounds);
textPaintFill.ImageFilter = SKImageFilter.CreateDropShadow(
dx,
dy,
sigmaX,
sigmaY,
SKColor.Parse("#55000000"));
textPaintFill.MeasureText(text, ref textBounds);
float xText = backendRenderTarget.Width / 2 - textBounds.MidX;
float yText = backendRenderTarget.Height / 2 - textBounds.MidY;
canvas.DrawText(text, xText, yText, textPaint);
canvas.DrawText(text, xText, yText, textPaintFill);
}
}
}
public override void PrepareOpenGL()
{
base.PrepareOpenGL();
// create the context
var glInterface = GRGlInterface.CreateNativeGlInterface();
context = GRContext.Create(GRBackend.OpenGL, glInterface);
renderTarget = SKGLDrawable.CreateRenderTarget();
}
public VulkanGpuSession(GRContext grContext,
GRBackendRenderTarget backendRenderTarget,
SKSurface surface,
VulkanSurfaceRenderingSession vulkanSession)
{
GrContext = grContext;
_backendRenderTarget = backendRenderTarget;
SkSurface = surface;
_vulkanSession = vulkanSession;
SurfaceOrigin = GRSurfaceOrigin.TopLeft;
}
void RenderWithSkia()
{
int width = glControl1.Width;
int height = glControl1.Height;
if (field == null || field.width != width || field.height != height)
{
field = new Starfield.Field(100_000, width, height);
}
field.StepForward();
// Create a Skia surface using the OpenGL control
SKColorType colorType = SKColorType.Rgba8888;
GRContext contextOpenGL = GRContext.Create(GRBackend.OpenGL, GRGlInterface.CreateNativeGlInterface());
GL.GetInteger(GetPName.FramebufferBinding, out var framebuffer);
GRGlFramebufferInfo glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
GL.GetInteger(GetPName.StencilBits, out var stencil);
GRBackendRenderTarget renderTarget = new GRBackendRenderTarget(width, height, contextOpenGL.GetMaxSurfaceSampleCount(colorType), stencil, glInfo);
SKSurface surface = SKSurface.Create(contextOpenGL, renderTarget, GRSurfaceOrigin.BottomLeft, colorType);
SKCanvas canvas = surface.Canvas;
// draw the starfield
var paint = new SKPaint
{
Color = SKColors.White,
IsAntialias = true
};
canvas.Clear(SKColors.Black);
foreach (Starfield.Star star in field.stars)
{
//canvas.DrawRect(star.X, star.Y, star.Size, star.Size, paint);
canvas.DrawCircle(new SKPoint(star.X, star.Y), star.Size / 2, paint);
}
// Force a display
surface.Canvas.Flush();
glControl1.SwapBuffers();
// dispose to prevent memory access violations while exiting
renderTarget?.Dispose();
contextOpenGL?.Dispose();
canvas?.Dispose();
surface?.Dispose();
// update the FPS display
renderCount += 1;
double elapsedSeconds = (double)stopwatch.ElapsedMilliseconds / 1000;
Text = string.Format("Rendered {0} frames in {1:0.00} seconds ({2:0.00} Hz)", renderCount, elapsedSeconds, renderCount / elapsedSeconds);
}
protected sealed override void CreateDrawingSurface()
{
if (glSurface == IntPtr.Zero)
{
// create the surface
glSurface = Evas.evas_gl_surface_create(glEvas, glConfigPtr, surfaceSize.Width, surfaceSize.Height);
// copy the native surface to the image
Evas.evas_gl_native_surface_get(glEvas, glSurface, out var nativeSurface);
Evas.evas_object_image_native_surface_set(evasImage, ref nativeSurface);
// switch to the current OpenGL context
Evas.evas_gl_make_current(glEvas, glSurface, glContext);
// resize the viewport
Gles.glViewport(0, 0, surfaceSize.Width, surfaceSize.Height);
// create the interface using the function pointers provided by the EFL
var glInterface = GRGlInterface.CreateEvas(glEvas);
if (glInterface == null)
{
Log.Error("SKGLSurfaceView", "Unable to create GRGlInterface.");
}
if (!glInterface.Validate())
{
Log.Error("SKGLSurfaceView", "The created GRGlInterface was not valid.");
}
context?.Dispose();
context = GRContext.CreateGl(glInterface);
if (context == null)
{
Log.Error("SKGLSurfaceView", "Unable to create the GRContext.");
}
// create the render target
renderTarget?.Dispose();
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
Gles.glGetIntegerv(Gles.GL_SAMPLES, out var samples);
var maxSamples = context.GetMaxSurfaceSampleCount(colorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget(surfaceSize.Width, surfaceSize.Height, samples, stencil, glInfo);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
canvas = surface.Canvas;
}
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
// clean up
surface?.Dispose();
surface = null;
renderTarget?.Dispose();
renderTarget = null;
grContext?.Dispose();
grContext = null;
}
public GlGpuSession(GRContext grContext,
GRBackendRenderTarget backendRenderTarget,
SKSurface surface,
IGlPlatformSurfaceRenderingSession glSession)
{
GrContext = grContext;
_backendRenderTarget = backendRenderTarget;
_surface = surface;
_glSession = glSession;
SurfaceOrigin = glSession.IsYFlipped ? GRSurfaceOrigin.TopLeft : GRSurfaceOrigin.BottomLeft;
}
