public void MakeCurrent(EGLSurface surface) { if (EGL.MakeCurrent(mEglDisplay, surface, surface, mEglContext) == EGL.FALSE) { throw new ApplicationException("Failed to make EGLSurface current"); } }
public void DestroySurface(EGLSurface surface) { if (mEglDisplay != EGL.NO_DISPLAY && surface != EGL.NO_SURFACE) { EGL.DestroySurface(mEglDisplay, surface); } }
public EGLSurface CreateSurface(SwapChainPanel panel, Size?renderSurfaceSize, float?resolutionScale) { if (panel == null) { throw new ArgumentException("SwapChainPanel parameter is invalid"); } if (renderSurfaceSize != null && resolutionScale != null) { throw new ArgumentException("A size and a scale can't both be specified"); } EGLSurface surface = EGL.NO_SURFACE; int[] surfaceAttributes = { // EGL.ANGLE_SURFACE_RENDER_TO_BACK_BUFFER is part of the same optimization as EGL.ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER (see above). // If you have compilation issues with it then please update your Visual Studio templates. EGL.ANGLE_SURFACE_RENDER_TO_BACK_BUFFER, EGL.TRUE, EGL.NONE }; // Create a PropertySet and initialize with the EGLNativeWindowType. PropertySet surfaceCreationProperties = new PropertySet(); surfaceCreationProperties.Add(ANGLEWindowsStore.EGLNativeWindowTypeProperty, panel); // If a render surface size is specified, add it to the surface creation properties if (renderSurfaceSize != null) { surfaceCreationProperties.Add(ANGLEWindowsStore.EGLRenderSurfaceSizeProperty, PropertyValue.CreateSize((Size)renderSurfaceSize)); } #if TODO // If a resolution scale is specified, add it to the surface creation properties if (resolutionScale != null) { surfaceCreationProperties.Add(ANGLEWindowsStore.EGLRenderResolutionScaleProperty, PropertyValue.CreateSingle(resolutionScale)); } #endif surface = EGL.CreateWindowSurface(mEglDisplay, mEglConfig, surfaceCreationProperties, surfaceAttributes); if (surface == EGL.NO_SURFACE) { throw new ApplicationException("Failed to create EGL surface"); } return(surface); }
void Cleanup() { if (mEglDisplay != EGL.NO_DISPLAY && mEglContext != EGL.NO_CONTEXT) { EGL.DestroyContext(mEglDisplay, mEglContext); mEglContext = EGL.NO_CONTEXT; } if (mEglDisplay != EGL.NO_DISPLAY) { EGL.Terminate(mEglDisplay); mEglDisplay = EGL.NO_DISPLAY; } }
void Initialize() { int[] configAttributes = { EGL.RED_SIZE, 8, EGL.GREEN_SIZE, 8, EGL.BLUE_SIZE, 8, EGL.ALPHA_SIZE, 8, EGL.DEPTH_SIZE, 8, EGL.STENCIL_SIZE, 8, EGL.NONE }; int[] contextAttributes = { EGL.CONTEXT_CLIENT_VERSION, 3, EGL.NONE }; int[] defaultDisplayAttributes = { // These are the default display attributes, used to request ANGLE's D3D11 renderer. // eglInitialize will only succeed with these attributes if the hardware supports D3D11 Feature Level 10_0+. EGL.PLATFORM_ANGLE_TYPE_ANGLE, EGL.PLATFORM_ANGLE_TYPE_D3D11_ANGLE, // EGL.ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER is an optimization that can have large performance benefits on mobile devices. // Its syntax is subject to change, though. Please update your Visual Studio templates if you experience compilation issues with it. EGL.ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.TRUE, // EGL.PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE is an option that enables ANGLE to automatically call // the IDXGIDevice3::Trim method on behalf of the application when it gets suspended. // Calling IDXGIDevice3::Trim when an application is suspended is a Windows Store application certification requirement. EGL.PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.TRUE, EGL.NONE, }; int[] fl9_3DisplayAttributes = { // These can be used to request ANGLE's D3D11 renderer, with D3D11 Feature Level 9_3. // These attributes are used if the call to eglInitialize fails with the default display attributes. EGL.PLATFORM_ANGLE_TYPE_ANGLE, EGL.PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL.PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, 9, EGL.PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE, 3, EGL.ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.TRUE, EGL.PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.TRUE, EGL.NONE, }; int[] warpDisplayAttributes = { // These attributes can be used to request D3D11 WARP. // They are used if eglInitialize fails with both the default display attributes and the 9_3 display attributes. EGL.PLATFORM_ANGLE_TYPE_ANGLE, EGL.PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL.PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGL.PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE, EGL.ANGLE_DISPLAY_ALLOW_RENDER_TO_BACK_BUFFER, EGL.TRUE, EGL.PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL.TRUE, EGL.NONE, }; // // To initialize the display, we make three sets of calls to eglGetPlatformDisplayEXT and eglInitialize, with varying // parameters passed to eglGetPlatformDisplayEXT: // 1) The first calls uses "defaultDisplayAttributes" as a parameter. This corresponds to D3D11 Feature Level 10_0+. // 2) If eglInitialize fails for step 1 (e.g. because 10_0+ isn't supported by the default GPU), then we try again // using "fl9_3DisplayAttributes". This corresponds to D3D11 Feature Level 9_3. // 3) If eglInitialize fails for step 2 (e.g. because 9_3+ isn't supported by the default GPU), then we try again // using "warpDisplayAttributes". This corresponds to D3D11 Feature Level 11_0 on WARP, a D3D11 software rasterizer. // // This tries to initialize EGL to D3D11 Feature Level 10_0+. See above comment for details. mEglDisplay = EGL.GetPlatformDisplayEXT(EGL.PLATFORM_ANGLE_ANGLE, EGL.DEFAULT_DISPLAY, defaultDisplayAttributes); if (mEglDisplay == EGL.NO_DISPLAY) { throw new ApplicationException("Failed to get EGL display"); } int major = 0, minor = 0; if (EGL.Initialize(mEglDisplay, ref major, ref minor) == EGL.FALSE) { // This tries to initialize EGL to D3D11 Feature Level 9_3, if 10_0+ is unavailable (e.g. on some mobile devices). mEglDisplay = EGL.GetPlatformDisplayEXT(EGL.PLATFORM_ANGLE_ANGLE, EGL.DEFAULT_DISPLAY, fl9_3DisplayAttributes); if (mEglDisplay == EGL.NO_DISPLAY) { throw new ApplicationException("Failed to get EGL display"); } if (EGL.Initialize(mEglDisplay, ref major, ref minor) == EGL.FALSE) { // This initializes EGL to D3D11 Feature Level 11_0 on WARP, if 9_3+ is unavailable on the default GPU. mEglDisplay = EGL.GetPlatformDisplayEXT(EGL.PLATFORM_ANGLE_ANGLE, EGL.DEFAULT_DISPLAY, warpDisplayAttributes); if (mEglDisplay == EGL.NO_DISPLAY) { throw new ApplicationException("Failed to get EGL display"); } if (EGL.Initialize(mEglDisplay, ref major, ref minor) == EGL.FALSE) { // If all of the calls to eglInitialize returned EGL.FALSE then an error has occurred. throw new ApplicationException("Failed to initialize EGL"); } } } int numConfigs = 0; var eglConfig = new EGLConfig[1]; if ((EGL.ChooseConfig(mEglDisplay, configAttributes, eglConfig, ref numConfigs) == EGL.FALSE) || (numConfigs == 0)) { throw new ApplicationException("Failed to choose first EGLConfig"); } else { mEglConfig = eglConfig[0]; } mEglContext = EGL.CreateContext(mEglDisplay, mEglConfig, EGL.NO_CONTEXT, contextAttributes); if (mEglContext == EGL.NO_CONTEXT) { throw new ApplicationException("Failed to create EGL context"); } }
public int SwapBuffers(EGLSurface surface) { return(EGL.SwapBuffers(mEglDisplay, surface)); }
public void GetSurfaceDimensions(EGLSurface surface, ref int width, ref int height) { EGL.QuerySurface(mEglDisplay, surface, EGL.WIDTH, ref width); EGL.QuerySurface(mEglDisplay, surface, EGL.HEIGHT, ref height); }