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(); }
private static GRContext GenerateSkiaContext(NativeWindow nativeWindow) { var nativeContext = Program.GetNativeContext(nativeWindow); var glInterface = GRGlInterface.AssembleGlInterface(nativeContext, (contextHandle, name) => Glfw.GetProcAddress(name)); return(GRContext.Create(GRBackend.OpenGL, glInterface)); }
public new void DrawInRect(GLKView view, CGRect rect) { if (designMode) { return; } if (context == null) { var glInterface = GRGlInterface.CreateNativeGlInterface(); context = GRContext.Create(GRBackend.OpenGL, glInterface); // get the initial details renderTarget = SKGLDrawable.CreateRenderTarget(); } // set the dimensions as they might have changed renderTarget.Width = (int)DrawableWidth; renderTarget.Height = (int)DrawableHeight; // create the surface using (var surface = SKSurface.Create(context, renderTarget)) { // draw on the surface DrawInSurface(surface, renderTarget); surface.Canvas.Flush(); } // flush the SkiaSharp contents to GL context.Flush(); }
public PlatformRenderInterface(ICustomSkiaGpu customSkiaGpu) { if (customSkiaGpu != null) { _customSkiaGpu = customSkiaGpu; GrContext = _customSkiaGpu.GrContext; return; } var gl = AvaloniaLocator.Current.GetService <IWindowingPlatformGlFeature>(); if (gl != null) { var display = gl.ImmediateContext.Display; gl.ImmediateContext.MakeCurrent(); using (var iface = display.Type == GlDisplayType.OpenGL2 ? GRGlInterface.AssembleGlInterface((_, proc) => display.GlInterface.GetProcAddress(proc)) : GRGlInterface.AssembleGlesInterface((_, proc) => display.GlInterface.GetProcAddress(proc))) { GrContext = GRContext.Create(GRBackend.OpenGL, iface); } display.ClearContext(); } }
public override void DrawInCGLContext(CGLContext glContext, CGLPixelFormat pixelFormat, double timeInterval, ref CVTimeStamp timeStamp) { CGLContext.CurrentContext = glContext; if (context == null) { // get the bits for SkiaSharp var glInterface = GRGlInterface.CreateNativeGlInterface(); context = GRContext.Create(GRBackend.OpenGL, glInterface); } // create the surface renderTarget = SKGLDrawable.CreateRenderTarget(); renderTarget.Width = (int)(Bounds.Width * ContentsScale); renderTarget.Height = (int)(Bounds.Height * ContentsScale); using (var surface = SKSurface.Create(context, renderTarget)) { // draw on the surface DrawInSurface(surface, renderTarget); SKDelegate?.DrawInSurface(surface, renderTarget); surface.Canvas.Flush(); } // flush the SkiaSharp context to the GL context context.Flush(); base.DrawInCGLContext(glContext, pixelFormat, timeInterval, ref timeStamp); }
private void DrawGpuTextureWithDesc(Action <SKSurface, GRGlBackendTextureDesc> draw) { using (var ctx = CreateGlContext()) { ctx.MakeCurrent(); // create the texture var textureInfo = ctx.CreateTexture(new SKSizeI(100, 100)); // this is a new field that was added to the struct textureInfo.Format = 0; var textureDesc = new GRGlBackendTextureDesc { Width = 100, Height = 100, Config = GRPixelConfig.Rgba8888, Flags = GRBackendTextureDescFlags.RenderTarget, Origin = GRSurfaceOrigin.BottomLeft, SampleCount = 0, TextureHandle = textureInfo, }; // create the surface using (var grContext = GRContext.Create(GRBackend.OpenGL)) using (var surface = SKSurface.CreateAsRenderTarget(grContext, textureDesc)) { Assert.NotNull(surface); draw(surface, textureDesc); } // clean up ctx.DestroyTexture(textureInfo.Id); } }
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; }
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 PrepareGLContexts() { // create GL context glContext = new EAGLContext(EAGLRenderingAPI.OpenGLES2); EAGLContext.SetCurrentContext(glContext); // create render buffer Gles.glGenRenderbuffers(1, ref renderBuffer); Gles.glBindRenderbuffer(Gles.GL_RENDERBUFFER, renderBuffer); glContext.RenderBufferStorage(Gles.GL_RENDERBUFFER, this); // create frame buffer Gles.glGenFramebuffers(1, ref framebuffer); Gles.glBindFramebuffer(Gles.GL_FRAMEBUFFER, framebuffer); Gles.glFramebufferRenderbuffer(Gles.GL_FRAMEBUFFER, Gles.GL_COLOR_ATTACHMENT0, Gles.GL_RENDERBUFFER, renderBuffer); // get the bits for SkiaSharp var glInterface = GRGlInterface.CreateNativeGlInterface(); context = GRContext.Create(GRBackend.OpenGL, glInterface); // finished EAGLContext.SetCurrentContext(null); recreateSurface = true; }
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e) { //base.OnPaint(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.Width = Width; renderTarget.Height = Height; // create the surface using (var surface = SKSurface.Create(grContext, renderTarget)) { if (PaintSurface != null) { PaintSurface.Invoke(surface); } // start drawing OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget)); surface.Canvas.Flush(); } // update the control SwapBuffers(); }
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(); this.KeyDown += (o, e) => { if (e.Key == Key.Escape) { this.Close(); } }; InputMouse = new InputMouse(this); InputMouse.MouseDown += state => Engine.OnMouse(state); InputMouse.MouseUp += state => Engine.OnMouse(state); InputMouse.MouseMove += state => Engine.OnMouse(state); InputMouse.MousePressedMove += state => Engine.OnMouse(state); FocusedChanged += OnFocusedChanged; // WindowState = WindowState.Fullscreen; CursorVisible = false; }
public void CreateSpecificContextIsValid() { using (var ctx = CreateGlContext()) { ctx.MakeCurrent(); var glInterface = GRGlInterface.CreateNativeGlInterface(); var grContext = GRContext.Create(GRBackend.OpenGL, glInterface); } }
public void CreateDefaultContextIsValid() { using (var ctx = CreateGlContext()) { ctx.MakeCurrent(); var grContext = GRContext.Create(GRBackend.OpenGL); Assert.NotNull(grContext); } }
public override void PrepareOpenGL() { base.PrepareOpenGL(); // create the context var glInterface = GRGlInterface.CreateNativeGlInterface(); context = GRContext.Create(GRBackend.OpenGL, glInterface); renderTarget = SKGLDrawable.CreateRenderTarget(); }
protected override void OnRenderFrame() { var rect = Allocation; // create the contexts if not done already if (grContext == null) { var glInterface = GRGlInterface.CreateNativeGlInterface(); if (glInterface == null) { Console.WriteLine("Error creating OpenGL ES interface. Check if you have OpenGL ES correctly installed and configured or change the PFD Renderer to 'Software (CPU)' on the Global Settings panel.", "Error Creating OpenGL ES interface"); System.Diagnostics.Process.GetCurrentProcess().Kill(); } else { grContext = GRContext.Create(GRBackend.OpenGL, glInterface); } try { renderTarget = CreateRenderTarget(); } catch (Exception ex) { Console.WriteLine("Error creating OpenGL ES render target. Check if you have OpenGL ES correctly installed and configured or change the PFD Renderer to 'Software (CPU)' on the Global Settings panel.\nError message:\n" + ex.ToString()); System.Diagnostics.Process.GetCurrentProcess().Kill(); } } if (grContext != null) { // update to the latest dimensions renderTarget.Width = rect.Width; renderTarget.Height = rect.Height; // create the surface using (var surface = SKSurface.Create(grContext, renderTarget)) { surface.Canvas.Clear(SKColors.White); // start drawing if (fsurface != null) { fsurface.UpdateSurface(surface); } // start drawing OnPaintSurface(new SKPaintGLSurfaceEventArgs(surface, renderTarget)); surface.Canvas.Flush(); } } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); if (DesignMode) { return; } Reshape(); grContext = GRContext.Create(GRBackend.OpenGL); }
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); }
public PlatformRenderInterface() { var gl = AvaloniaLocator.Current.GetService <IWindowingPlatformGlFeature>(); if (gl != null) { var display = gl.ImmediateContext.Display; var iface = display.Type == GlDisplayType.OpenGL2 ? GRGlInterface.AssembleGlInterface((_, proc) => display.GlInterface.GetProcAddress(proc)) : GRGlInterface.AssembleGlesInterface((_, proc) => display.GlInterface.GetProcAddress(proc)); gl.ImmediateContext.MakeCurrent(); GrContext = GRContext.Create(GRBackend.OpenGL, iface); } }
private void RenderWithOpenGL(object sender, PaintEventArgs e) { Control sctl = (Control)sender; int width = sctl.Width; int height = sctl.Height; // setup the Skia surface using OpenGL 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); // Draw some stuff on the canvas surface.Canvas.Clear(SKColor.Parse("#FFFFFF")); // adds about 3ms fullscreen byte alpha = 128; var paint = new SKPaint(); for (int i = 0; i < 1_000; i++) { float x1 = (float)(rand.NextDouble() * width); float x2 = (float)(rand.NextDouble() * width); float y1 = (float)(rand.NextDouble() * height); float y2 = (float)(rand.NextDouble() * height); paint.Color = new SKColor( red: (byte)(rand.NextDouble() * 255), green: (byte)(rand.NextDouble() * 255), blue: (byte)(rand.NextDouble() * 255), alpha: alpha ); surface.Canvas.DrawLine(x1, y1, x2, y2, paint); } surface.Canvas.Flush(); glControl1.SwapBuffers(); // prevent memory access violations by disposing before exiting renderTarget?.Dispose(); contextOpenGL?.Dispose(); surface?.Dispose(); }
private void InitSkia() { _skInterface = GRGlInterface.CreateNativeGlInterface(); if (_skInterface == null) { throw new Exception($"Failed to create SkiaSharp OpenGL interface."); } _skContext = GRContext.Create(GRBackend.OpenGL, _skInterface); if (_skContext == null) { throw new Exception($"Failed to create SkiaSharp OpenGL context."); } ResizeScreen(); var fontName = _config.Text.Font; _skFont = SKTypeface.FromFile(fontName) ?? SKTypeface.FromFamilyName(fontName); _skFillPaint = new SKPaint() { BlendMode = SKBlendMode.SrcOver, Color = _config.Text.FillColor, IsAntialias = true, Style = SKPaintStyle.Fill, TextAlign = _config.Text.Align, TextSize = _config.Text.Size, Typeface = _skFont, }; if (_config.Text.StrokeWidth > 0) { _skStrokePaint = new SKPaint() { BlendMode = SKBlendMode.SrcOver, Color = _config.Text.StrokeColor, IsAntialias = true, StrokeCap = _config.Text.StrokeCap, StrokeJoin = _config.Text.StrokeJoin, StrokeMiter = _config.Text.StrokeMiter, StrokeWidth = _config.Text.StrokeWidth, Style = SKPaintStyle.Stroke, TextAlign = _config.Text.Align, TextSize = _config.Text.Size, Typeface = _skFont, }; } }
public new void DrawInRect(GLKView view, CGRect rect) { if (designMode) { return; } // create the contexts if not done already if (context == null) { var glInterface = GRGlInterface.CreateNativeGlInterface(); context = GRContext.Create(GRBackend.OpenGL, glInterface); } // manage the drawing surface if (renderTarget == null || surface == null || renderTarget.Width != DrawableWidth || renderTarget.Height != DrawableHeight) { // create or update the dimensions 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; } var glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat()); renderTarget = new GRBackendRenderTarget((int)DrawableWidth, (int)DrawableHeight, samples, stencil, glInfo); // create the surface surface?.Dispose(); surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType); } using (new SKAutoCanvasRestore(surface.Canvas, true)) { // start drawing var e = new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType); OnPaintSurface(e); #pragma warning disable CS0618 // Type or member is obsolete DrawInSurface(e.Surface, e.RenderTarget); #pragma warning restore CS0618 // Type or member is obsolete } // flush the SkiaSharp contents to GL surface.Canvas.Flush(); context.Flush(); }
public Renderer() { GRGlInterface glInterface = GRGlInterface.CreateNativeGlInterface(); Context = GRContext.Create(GRBackend.OpenGL, glInterface); RenderTarget = new GRBackendRenderTargetDesc { Config = GRPixelConfig.Bgra8888, Origin = GRSurfaceOrigin.BottomLeft, SampleCount = 0, StencilBits = 8, RenderTargetHandle = (IntPtr)0 }; }
public Renderer() { var glInterface = GRGlInterface.CreateNativeGlInterface(); Context = GRContext.Create(GRBackend.OpenGL, glInterface); GL.GetFramebufferAttachmentParameter(FramebufferTarget.Framebuffer, FramebufferAttachment.FrontLeft, FramebufferParameterName.FramebufferAttachmentStencilSize, out var stencilBits); RenderTarget = new GRBackendRenderTargetDesc { Config = GRPixelConfig.Bgra8888, Origin = GRSurfaceOrigin.BottomLeft, SampleCount = 0, StencilBits = stencilBits, RenderTargetHandle = (IntPtr)0 }; }
public void GpuSurfaceIsCreated() { using (var ctx = CreateGlContext()) { ctx.MakeCurrent(); using (var grContext = GRContext.Create(GRBackend.OpenGL)) using (var surface = SKSurface.Create(grContext, true, new SKImageInfo(100, 100))) { Assert.NotNull(surface); var canvas = surface.Canvas; Assert.NotNull(canvas); canvas.Clear(SKColors.Transparent); } } }
void Render() { // Create a Skia surface using the OpenGL control int width = glControl1.Width; int height = glControl1.Height; 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 some lines canvas.Clear(SKColor.Parse("#003366")); var paint = new SKPaint { Color = new SKColor(255, 255, 255, 50), IsAntialias = true }; for (int i = 0; i < 1_000; i++) { SKPoint ptA = new SKPoint(rand.Next(width), rand.Next(height)); SKPoint ptB = new SKPoint(rand.Next(width), rand.Next(height)); canvas.DrawLine(ptA, ptB, 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); }
public Window(string title, int w, int h) { const int x = SDL.SDL_WINDOWPOS_CENTERED; const int y = SDL.SDL_WINDOWPOS_CENTERED; SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MINOR_VERSION, 0); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_PROFILE_MASK, (int)SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_CORE); int kStencilBits = 8; // Skia needs 8 stencil bits SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_RED_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_GREEN_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_BLUE_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_DOUBLEBUFFER, 1); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_DEPTH_SIZE, 0); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_STENCIL_SIZE, kStencilBits); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_ACCELERATED_VISUAL, 1); _window = SDL.SDL_CreateWindow(title, x, y, w, h, WINDOW_FLAGS); // try and setup a GL context _glContext = SDL.SDL_GL_CreateContext(_window); if (_glContext == IntPtr.Zero) { throw new Exception("Unable to create OpenGL context."); } SDL.SDL_GL_MakeCurrent(_window, _glContext); var windowFormat = SDL.SDL_GetWindowPixelFormat(_window); int contextType; SDL.SDL_GL_GetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_PROFILE_MASK, out contextType); /*glViewport(0, 0, dw, dh); * glClearColor(1, 1, 1, 1); * glClearStencil(0); * glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);*/ var grInterface = GRGlInterface.CreateNativeGlInterface(); var grContext = GRContext.Create(GRBackend.OpenGL, grInterface); _surface = SKSurface.Create(grContext, CreateRenderTarget()); }
private void DrawGpuSurface(Action <SKSurface, SKImageInfo> draw) { using (var ctx = CreateGlContext()) { ctx.MakeCurrent(); var info = new SKImageInfo(100, 100); using (var grContext = GRContext.Create(GRBackend.OpenGL)) using (var surface = SKSurface.Create(grContext, true, info)) { Assert.NotNull(surface); draw(surface, info); } } }
protected override void OnRenderFrame() { var rect = Allocation; // create the contexts if not done already if (grContext == null) { var glInterface = GRGlInterface.CreateNativeGlInterface(); if (glInterface == null) { throw new InvalidOperationException("Error creating OpenGL ES interface. Check if you have OpenGL ES correctly installed and configured or change the PFD Renderer to 'Software (CPU)' on the Global Settings panel."); } else { grContext = GRContext.Create(GRBackend.OpenGL, glInterface); } try { renderTarget = CreateRenderTarget(); } catch (Exception ex) { throw new InvalidOperationException("Error creating OpenGL ES render target. Check if you have OpenGL ES correctly installed and configured or change the PFD Renderer to 'Software (CPU)' on the Global Settings panel.", ex); } } if (grContext != null) { // update to the latest dimensions renderTarget = new GRBackendRenderTarget(rect.Width, rect.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); } surface.Canvas.Flush(); } } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); GlobalResources.OpenGLInterface = GRGlInterface.CreateNativeGlInterface(); Debug.Assert(GlobalResources.OpenGLInterface.Validate()); this.context = GRContext.Create(GRBackend.OpenGL, GlobalResources.OpenGLInterface); Debug.Assert(this.context.Handle != IntPtr.Zero); this.renderTarget = CreateRenderTarget(this); CursorVisible = true; Location = new Point(Location.X, 0); _Present = new GamePresenter(this); StartGame(); CurrentState = new GenericMenuState(StandardImageBackgroundSkia.GetMenuBackgroundDrawer(), this, new TitleMenuPopulator()) { StateHeader = "BASeTris" }; }
public GlSkiaGpu(IWindowingPlatformGlFeature gl, long?maxResourceBytes) { var context = gl.MainContext; using (context.MakeCurrent()) { using (var iface = context.Version.Type == GlProfileType.OpenGL ? GRGlInterface.AssembleGlInterface((_, proc) => context.GlInterface.GetProcAddress(proc)) : GRGlInterface.AssembleGlesInterface((_, proc) => context.GlInterface.GetProcAddress(proc))) { _grContext = GRContext.Create(GRBackend.OpenGL, iface); if (maxResourceBytes.HasValue) { _grContext.GetResourceCacheLimits(out var maxResources, out _); _grContext.SetResourceCacheLimits(maxResources, maxResourceBytes.Value); } } } }