public IGlContext CreateContext(IGlContext share)
{
var shareCtx = (EglContext)share;
var ctx = _egl.CreateContext(_display, _config, shareCtx?.Context ?? IntPtr.Zero, _contextAttributes);
if (ctx == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreateContext", _egl);
}
var surf = _egl.CreatePBufferSurface(_display, _config, new[]
{
EGL_WIDTH, 1,
EGL_HEIGHT, 1,
EGL_NONE
});
if (surf == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreatePBufferSurface", _egl);
}
var rv = new EglContext(this, _egl, ctx, surf);
rv.MakeCurrent(null);
return(rv);
}
public void ClearContext()
{
if (!_egl.MakeCurrent(_display, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
}
public EglContext CreateContext(IGlContext share)
{
if ((_surfaceType | EGL_PBUFFER_BIT) == 0)
{
throw new InvalidOperationException("Platform doesn't support PBUFFER surfaces");
}
var shareCtx = (EglContext)share;
var ctx = _egl.CreateContext(_display, _config, shareCtx?.Context ?? IntPtr.Zero, _contextAttributes);
if (ctx == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreateContext", _egl);
}
var surf = _egl.CreatePBufferSurface(_display, _config, new[]
{
EGL_WIDTH, 1,
EGL_HEIGHT, 1,
EGL_NONE
});
if (surf == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreatePBufferSurface", _egl);
}
var rv = new EglContext(this, _egl, ctx, new EglSurface(this, _egl, surf));
rv.MakeCurrent(null);
return(rv);
}
public void MakeCurrent()
{
if (!_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
}
static IntPtr CreateDisplay(EglInterface egl, int platformType, IntPtr platformDisplay, int[] attrs)
{
var display = IntPtr.Zero;
if (platformType == -1 && platformDisplay == IntPtr.Zero)
{
if (display == IntPtr.Zero)
{
display = egl.GetDisplay(IntPtr.Zero);
}
}
else
{
if (egl.GetPlatformDisplayEXT == null)
{
throw new OpenGlException("eglGetPlatformDisplayEXT is not supported by libegl");
}
display = egl.GetPlatformDisplayEXT(platformType, platformDisplay, attrs);
}
if (display == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglGetDisplay", egl);
}
return(display);
}
public void MakeCurrent(EglSurface surface)
{
var surf = surface?.DangerousGetHandle() ?? OffscreenSurface;
if (!_egl.MakeCurrent(_disp.Handle, surf, surf, Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
}
public EglSurface CreateWindowSurface(IntPtr window)
{
var s = _egl.CreateWindowSurface(_display, _config, window, new[] { EGL_NONE, EGL_NONE });
if (s == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreateWindowSurface", _egl);
}
return(new EglSurface(this, _egl, s));
}
public IDisposable MakeCurrent()
{
var old = new RestoreContext(_egl, _disp.Handle);
_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
return(old);
}
public EglSurface CreatePBufferFromClientBuffer(int bufferType, IntPtr handle, int[] attribs)
{
var s = _egl.CreatePbufferFromClientBuffer(_display, bufferType, handle,
_config, attribs);
if (s == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreatePbufferFromClientBuffer", _egl);
}
return(new EglSurface(this, _egl, s));
}
public IDisposable MakeCurrent(EglSurface surface)
{
var old = new RestoreContext(_egl, _disp.Handle);
var surf = surface ?? OffscreenSurface;
_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!_egl.MakeCurrent(_disp.Handle, surf.DangerousGetHandle(), surf.DangerousGetHandle(), Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
return(old);
}
public EglContext CreateContext(EglContext share, EglSurface offscreenSurface)
{
var ctx = _egl.CreateContext(_display, _config, share?.Context ?? IntPtr.Zero, _contextAttributes);
if (ctx == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglCreateContext", _egl);
}
var rv = new EglContext(this, _egl, ctx, offscreenSurface);
rv.MakeCurrent(null);
return(rv);
}
public EglDisplay(EglInterface egl, int platformType, IntPtr platformDisplay, int[] attrs)
{
_egl = egl;
if (platformType == -1 && platformDisplay == IntPtr.Zero)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
if (_egl.GetPlatformDisplayEXT == null)
{
throw new OpenGlException("eglGetPlatformDisplayEXT is not supported by libegl.dll");
}
var allowedApis = AvaloniaLocator.Current.GetService <AngleOptions>()?.AllowedPlatformApis
?? new List <AngleOptions.PlatformApi> {
AngleOptions.PlatformApi.DirectX9
};
foreach (var platformApi in allowedApis)
{
int dapi;
if (platformApi == AngleOptions.PlatformApi.DirectX9)
{
dapi = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
}
else if (platformApi == AngleOptions.PlatformApi.DirectX11)
{
dapi = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
}
else
{
continue;
}
_display = _egl.GetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, IntPtr.Zero,
new[] { EGL_PLATFORM_ANGLE_TYPE_ANGLE, dapi, EGL_NONE });
if (_display != IntPtr.Zero)
{
_angleApi = platformApi;
break;
}
}
if (_display == IntPtr.Zero)
{
throw new OpenGlException("Unable to create ANGLE display");
}
}
if (_display == IntPtr.Zero)
{
_display = _egl.GetDisplay(IntPtr.Zero);
}
}
else
{
if (_egl.GetPlatformDisplayEXT == null)
{
throw new OpenGlException("eglGetPlatformDisplayEXT is not supported by libegl");
}
_display = _egl.GetPlatformDisplayEXT(platformType, platformDisplay, attrs);
}
if (_display == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglGetDisplay", _egl);
}
if (!_egl.Initialize(_display, out var major, out var minor))
{
throw OpenGlException.GetFormattedException("eglInitialize", _egl);
}
foreach (var cfg in new[]
{
new
{
Attributes = new[] { EGL_NONE },
Api = EGL_OPENGL_API,
RenderableTypeBit = EGL_OPENGL_BIT,
Type = GlDisplayType.OpenGL2
},
new
{
Attributes = new[]
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
},
Api = EGL_OPENGL_ES_API,
RenderableTypeBit = EGL_OPENGL_ES2_BIT,
Type = GlDisplayType.OpenGLES2
}
})
{
if (!_egl.BindApi(cfg.Api))
{
continue;
}
foreach (var surfaceType in new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT })
{
foreach (var stencilSize in new[] { 8, 1, 0 })
{
foreach (var depthSize in new [] { 8, 1, 0 })
{
var attribs = new[]
{
EGL_SURFACE_TYPE, surfaceType,
EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_STENCIL_SIZE, stencilSize,
EGL_DEPTH_SIZE, depthSize,
EGL_NONE
};
if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
{
continue;
}
if (numConfigs == 0)
{
continue;
}
_contextAttributes = cfg.Attributes;
_surfaceType = surfaceType;
Type = cfg.Type;
}
}
}
}
if (_contextAttributes == null)
{
throw new OpenGlException("No suitable EGL config was found");
}
GlInterface = GlInterface.FromNativeUtf8GetProcAddress(b => _egl.GetProcAddress(b));
}
public EglDisplay(EglInterface egl)
{
_egl = egl;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && _egl.GetPlatformDisplayEXT != null)
{
foreach (var dapi in new[] { EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE })
{
_display = _egl.GetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new[]
{
EGL_PLATFORM_ANGLE_TYPE_ANGLE, dapi, EGL_NONE
});
if (_display != IntPtr.Zero)
{
break;
}
}
}
if (_display == IntPtr.Zero)
{
_display = _egl.GetDisplay(IntPtr.Zero);
}
if (_display == IntPtr.Zero)
{
throw OpenGlException.GetFormattedException("eglGetDisplay", _egl);
}
if (!_egl.Initialize(_display, out var major, out var minor))
{
throw OpenGlException.GetFormattedException("eglInitialize", _egl);
}
foreach (var cfg in new[]
{
new
{
Attributes = new[] { EGL_NONE },
Api = EGL_OPENGL_API,
RenderableTypeBit = EGL_OPENGL_BIT,
Type = GlDisplayType.OpenGL2
},
new
{
Attributes = new[]
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
},
Api = EGL_OPENGL_ES_API,
RenderableTypeBit = EGL_OPENGL_ES2_BIT,
Type = GlDisplayType.OpenGLES2
}
})
{
if (!_egl.BindApi(cfg.Api))
{
continue;
}
var attribs = new[]
{
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_STENCIL_SIZE, 8,
EGL_DEPTH_SIZE, 8,
EGL_NONE
};
if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
{
continue;
}
if (numConfigs == 0)
{
continue;
}
_contextAttributes = cfg.Attributes;
Type = cfg.Type;
}
if (_contextAttributes == null)
{
throw new OpenGlException("No suitable EGL config was found");
}
GlInterface = new GlInterface((proc, optional) =>
{
using (var u = new Utf8Buffer(proc))
{
var rv = _egl.GetProcAddress(u);
if (rv == IntPtr.Zero && !optional)
{
throw new OpenGlException("Missing function " + proc);
}
return(rv);
}
});
}
public EglDisplay(EglInterface egl, IntPtr display)
{
_egl = egl;
_display = display;
if (_display == IntPtr.Zero)
{
throw new ArgumentException();
}
if (!_egl.Initialize(_display, out var major, out var minor))
{
throw OpenGlException.GetFormattedException("eglInitialize", _egl);
}
var glProfiles = AvaloniaLocator.Current.GetService <AngleOptions>()?.GlProfiles
?? new[]
{
new GlVersion(GlProfileType.OpenGLES, 3, 0),
new GlVersion(GlProfileType.OpenGLES, 2, 0)
};
var cfgs = glProfiles.Select(x =>
{
var typeBit = EGL_OPENGL_ES3_BIT;
switch (x.Major)
{
case 2:
typeBit = EGL_OPENGL_ES2_BIT;
break;
case 1:
typeBit = EGL_OPENGL_ES_BIT;
break;
}
return(new
{
Attributes = new[]
{
EGL_CONTEXT_MAJOR_VERSION, x.Major,
EGL_CONTEXT_MINOR_VERSION, x.Minor,
EGL_NONE
},
Api = EGL_OPENGL_ES_API,
RenderableTypeBit = typeBit,
Version = x
});
});
foreach (var cfg in cfgs)
{
if (!_egl.BindApi(cfg.Api))
{
continue;
}
foreach (var surfaceType in new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT })
{
foreach (var stencilSize in new[] { 8, 1, 0 })
{
foreach (var depthSize in new [] { 8, 1, 0 })
{
var attribs = new[]
{
EGL_SURFACE_TYPE, surfaceType,
EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_STENCIL_SIZE, stencilSize,
EGL_DEPTH_SIZE, depthSize,
EGL_NONE
};
if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
{
continue;
}
if (numConfigs == 0)
{
continue;
}
_contextAttributes = cfg.Attributes;
_surfaceType = surfaceType;
_version = cfg.Version;
_egl.GetConfigAttrib(_display, _config, EGL_SAMPLES, out _sampleCount);
_egl.GetConfigAttrib(_display, _config, EGL_STENCIL_SIZE, out _stencilSize);
goto Found;
}
}
}
}
Found:
if (_contextAttributes == null)
{
throw new OpenGlException("No suitable EGL config was found");
}
}
public EglDisplay(EglInterface egl, IntPtr display)
{
_egl = egl;
_display = display;
if (_display == IntPtr.Zero)
{
throw new ArgumentException();
}
if (!_egl.Initialize(_display, out var major, out var minor))
{
throw OpenGlException.GetFormattedException("eglInitialize", _egl);
}
foreach (var cfg in new[]
{
new
{
Attributes = new[]
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
},
Api = EGL_OPENGL_ES_API,
RenderableTypeBit = EGL_OPENGL_ES2_BIT,
Version = new GlVersion(GlProfileType.OpenGLES, 2, 0)
}
})
{
if (!_egl.BindApi(cfg.Api))
{
continue;
}
foreach (var surfaceType in new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT })
{
foreach (var stencilSize in new[] { 8, 1, 0 })
{
foreach (var depthSize in new [] { 8, 1, 0 })
{
var attribs = new[]
{
EGL_SURFACE_TYPE, surfaceType,
EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_STENCIL_SIZE, stencilSize,
EGL_DEPTH_SIZE, depthSize,
EGL_NONE
};
if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
{
continue;
}
if (numConfigs == 0)
{
continue;
}
_contextAttributes = cfg.Attributes;
_surfaceType = surfaceType;
_version = cfg.Version;
_egl.GetConfigAttrib(_display, _config, EGL_SAMPLES, out _sampleCount);
_egl.GetConfigAttrib(_display, _config, EGL_STENCIL_SIZE, out _stencilSize);
goto Found;
}
}
}
}
Found:
if (_contextAttributes == null)
{
throw new OpenGlException("No suitable EGL config was found");
}
}