How to obtain native OpenGL Context and Device Context IntPtr from OpenGlControlBase for 3rd-party interop (Linux/Windows)?

[ulig123]

Hi,

I am currently working on a custom control that inherits from Avalonia.OpenGL.Controls.OpenGlControlBase. My goal is to integrate a 3rd-party native graphics library that requires direct access to an active OpenGL rendering context and its associated "device context" or "drawable surface" to perform its drawing operations. This involves providing IntPtr handles to the openGl-Context and the device context.

As I understand it, on Windows, Avalonia utilizes ANGLE, which in turn leverages EGL to translate OpenGL ES calls into DirectX. On Linux, EGL (e.g., with Wayland) or GLX (with X11) would be used.

I need to obtain the native IntPtr for:

The OpenGL rendering context that OpenGlControlBase has created and manages.

The associated device context / drawable / surface handle (e.g., HDC on Windows, Drawable/EGLSurface on Linux) that the OpenGL context is bound to, and into which the 3rd-party library should draw.

For this I was trying to instanciate the EglInterface class since it contains a methode GetCurrentContext(). However the constructor excepts a string library. To get this working on Windows, I would need a dll that hosts the EGL implementation, probably something similar to libGLESv2.dll. However, in my output directory there is no such dll.

Does anybody know how I can get the native IntPtr to the created OpenGL-context for plattforms like Linux and Windows?
Is there a way to access the native IntPtr from the OpenGLControlBase?

See attached sample from the OnOpenGlInit override for the EglInterface.

    /// <summary>
    /// This method is called when the OpenGL context is initialized.
    /// </summary>
    /// <param name="GL"></param>
    protected override unsafe void OnOpenGlInit(GlInterface GL)
    {
        CheckError(GL);

        Info = $"Vendor: {GL.GetString(GlConsts.GL_VENDOR)} | Renderer: {GL.GetString(GlConsts.GL_RENDERER)} | Version: {GL.GetString(GlConsts.GL_VERSION)}";
        Info += $"\nExtensions: {GL.GetString(GlConsts.GL_EXTENSIONS)}"; 
        CheckError(GL);

        // create new openGL EGL class
        var egl = new EglInterface("libGLESv2.dll");
        IntPtr contextPtr = egl.GetCurrentContext();

        if (contextPtr == IntPtr.Zero)
        {
        }

        _nativeGlContextHandle = contextPtr;

[kekekeks]

My goal is to integrate a 3rd-party native graphics library that requires direct access to an active OpenGL rendering context and its associated "device context" or "drawable surface" to perform its drawing operations.

Then you need to use our graphics interop APIs. Please, check GpuInterop demo and see how to set up GPU surface sharing.

[ulig123]

What is the proposed way to do this? Is it meant to use a library like Silk.net that creates a openGl context that will then be shared via the GPU interop api or it is similar to the approach in the OpenGLControlBaseResources file? I am using the DrawSurfaceBaseDemo from the GPUInterop Demo as a foundation to create my visual. However, when trying to create a shared context I am getting an error message that says that a egl context is already present ( "EGL context already present?"). See a sample of my intializeGraphicRessources method below.

Also when creating a shared context I would get an instance of the IGLContext. Any way on how to get the IntPtr to the context or is it really necessary to use a 3rd party library that creates the openGL context?

I was looking into the samples using directX and Vulkan but do not really get how to transport it to OpenGL. Any examples or guidelines would be really helpful here. The DrawingSurfaceDemoBase is designed to import a pre-rendered GPU image (a texture) into the CompositionDrawingSurface. The Direct3D11 and Vulkan examples demonstrate how to create an offscreen framebuffer, render into it, and then obtain a shareable handle of the resulting texture for import via ICompositionGpuInterop.ImportImage(). How does this process work equivalently for OpenGL with ANGLE/EGL?

Can anyone help me out on this one?

public class OpenGLDrawingControl : CustomDrawingSurfaceControl
{
    private IGlContext? _glContext;
    private GL? _gl;

    protected override (bool success, string info) InitializeGraphicsResources(
        Compositor compositor,
        CompositionDrawingSurface compositionDrawingSurface, ICompositionGpuInterop gpuInterop)
    {
        var featureObj = compositor.TryGetRenderInterfaceFeature(typeof(IOpenGlTextureSharingRenderInterfaceContextFeature)).GetAwaiter().GetResult();
        if (featureObj is not IOpenGlTextureSharingRenderInterfaceContextFeature feature)

        {
            return (false, "Failed to obtain OpenGL texture sharing feature");
        }

        // create OpenGL context
        try
        {
            feature.CreateSharedContext();
        }
        catch (Exception e)
        {
            Debug.WriteLine($"OpenGL context creation error: {e}");
            return (false, $"Failed to create OpenGL context: {e.Message}");
        }
        if (_glContext is null)
        {
            return (false, "Failed to create OpenGL context for CompositionDrawingSurface");
        }

        return (true, "OpenGL context created and initialized");
    }

[kekekeks]

With ANGLE you can import an existing Direct3D texture as EGLSurface. Here is an example code here (note that it's not an Avalonia public API, you'll need to do the relevant EGL calls yourself):

Avalonia/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs

Lines 198 to 204 in aa25441

	public unsafe EglSurface WrapDirect3D11Texture( IntPtr handle)
	{
	if (PlatformApi != AngleOptions.PlatformApi.DirectX11)
	ThrowInvalidPlatformApi();
	var attrs = stackalloc[] { EGL_NONE, EGL_NONE };
	return CreatePBufferFromClientBuffer(EGL_D3D_TEXTURE_ANGLE, handle, attrs);
	}