Rendering Pipeline and Backends

public class PlatformRenderInterface : IPlatformRenderInterface
{
    public IPlatformRenderInterfaceContext CreateBackendContext(
        IPlatformGraphicsContext? graphicsContext)
    {
        if (graphicsContext == null)
            return new SkiaContext(null);
        if (graphicsContext is ISkiaGpu skiaGpu)
            return new SkiaContext(skiaGpu);
        if (graphicsContext is IGlContext gl)
            return new SkiaContext(new GlSkiaGpu(gl, maxResourceBytes));
        if (graphicsContext is IMetalDevice metal)
            return new SkiaContext(new SkiaMetalGpu(metal, maxResourceBytes));
        if (graphicsContext is IVulkanPlatformGraphicsContext vulkanContext)
            return new SkiaContext(new VulkanSkiaGpu(vulkanContext, maxResourceBytes));
    }
}

using Avalonia;
using Avalonia.Skia;

AppBuilder.Configure<App>()
    .UsePlatformDetect()
    // Force software rendering
    .With(new SkiaOptions
    {
        // Disable GPU acceleration
        MaxGpuResourceSizeBytes = 0
    })
    // OR configure GPU memory limit
    .With(new SkiaOptions
    {
        MaxGpuResourceSizeBytes = 256 * 1024 * 1024 // 256 MB
    })
    .StartWithClassicDesktopLifetime(args);

public interface IGlContext
{
    GRContext CreateBackendContext();
    IDisposable MakeCurrent();
    void SwapBuffers();
}

using Avalonia.Vulkan;

// Vulkan is automatically used when available
// No explicit configuration required

using Avalonia.Metal;

// Metal backend is automatically selected on macOS/iOS
// when hardware supports it

internal partial class DrawingContextImpl : IDrawingContextImpl,
    IDrawingContextWithAcrylicLikeSupport,
    IDrawingContextImplWithEffects
{
    private readonly SKCanvas _canvas;
    private readonly Vector _intermediateSurfaceDpi;
    private readonly Stack<(SKMatrix matrix, PaintWrapper paint)> _maskStack;
    private readonly Stack<double> _opacityStack;
    private readonly Stack<RenderOptions> _renderOptionsStack;
    private readonly Stack<TextOptions> _textOptionsStack;
    private readonly GRContext? _grContext;
    private readonly ISkiaGpu? _gpu;
}

using Avalonia.Media;
using Avalonia.Rendering.SceneGraph;

public class CustomControl : Control
{
    public override void Render(DrawingContext context)
    {
        base.Render(context);

        // Draw a rectangle
        var brush = new SolidColorBrush(Colors.Blue);
        var pen = new Pen(Brushes.Black, 2);
        context.DrawRectangle(brush, pen, new Rect(10, 10, 100, 50));

        // Draw an ellipse
        context.DrawEllipse(Brushes.Red, null, new Point(150, 35), 40, 25);

        // Draw text
        var formattedText = new FormattedText(
            "Hello Avalonia",
            CultureInfo.CurrentCulture,
            FlowDirection.LeftToRight,
            new Typeface(FontFamily.Default),
            16,
            Brushes.Black);
        context.DrawText(formattedText, new Point(10, 70));

        // Draw a path
        var geometry = Geometry.Parse("M 0,0 L 100,0 L 50,50 Z");
        context.DrawGeometry(Brushes.Green, pen, geometry);
    }
}

public interface IRenderLoop
{
    void Add(IRenderLoopTask task);
    void Remove(IRenderLoopTask task);
}

public interface IRenderLoopTask
{
    bool NeedsUpdate { get; }
    void Update(TimeSpan time);
    void Render();
}

using Avalonia.Rendering;

public class MyRenderLoopTask : IRenderLoopTask
{
    public bool NeedsUpdate { get; private set; }

    public void Update(TimeSpan time)
    {
        // Update logic before rendering
        NeedsUpdate = true;
    }

    public void Render()
    {
        // Perform rendering
        NeedsUpdate = false;
    }
}

// Register with render loop
AvaloniaLocator.Current
    .GetService<IRenderLoop>()
    .Add(myRenderLoopTask);

// Invalidate only changed regions
control.InvalidateVisual(); // Invalidate entire control

// Or invalidate specific region
control.InvalidateVisual(new Rect(x, y, width, height));

using Avalonia.Media.Imaging;

private RenderTargetBitmap? _cachedBitmap;

public void CacheRendering(Visual visual, Size size)
{
    var pixelSize = new PixelSize((int)size.Width, (int)size.Height);
    _cachedBitmap = new RenderTargetBitmap(pixelSize);
    
    using (var context = _cachedBitmap.CreateDrawingContext(null))
    {
        // Render visual to bitmap
        visual.Render(context);
    }
}

public override void Render(DrawingContext context)
{
    if (_cachedBitmap != null)
    {
        context.DrawImage(_cachedBitmap, 
            new Rect(0, 0, _cachedBitmap.PixelSize.Width, _cachedBitmap.PixelSize.Height));
    }
}

<!-- RenderTransform: GPU-accelerated, no layout pass -->
<Border RenderTransform="scale(2)" />

<!-- LayoutTransform: Affects layout, triggers measure/arrange -->
<Border LayoutTransform="scale(2)" />

public bool IsSupportedBitmapPixelFormat(PixelFormat format) =>
    format == PixelFormats.Rgb565
    || format == PixelFormats.Bgra8888
    || format == PixelFormats.Rgba8888;

// Get DPI information
var screen = control.GetVisualRoot() as Window;
if (screen != null)
{
    var scaling = screen.RenderScaling; // e.g., 1.5 for 150% DPI
}

// Create scaled render target
var dpi = new Vector(96 * scaling, 96 * scaling);
var bitmap = new RenderTargetBitmap(
    new PixelSize(width, height),
    dpi);

<Image RenderOptions.BitmapInterpolationMode="HighQuality"
       RenderOptions.BitmapBlendingMode="SourceOver" />

<TextBlock RenderOptions.TextRenderingMode="Antialias" />

using Avalonia.Rendering;

// Enable renderer debug overlays
RendererDiagnostics.DebugOverlays = RendererDebugOverlays.Fps 
                                  | RendererDebugOverlays.LayoutTimeGraph
                                  | RendererDebugOverlays.RenderTimeGraph;