A connection to an EGL display. Only one connection per application instance is sufficient. More...

#include <display.h>

Public Member Functions
	Display ()

virtual	~Display ()

virtual bool	IsValid () const

virtual std::unique_ptr< Config >	ChooseConfig (ConfigDescriptor config) const
	Choose a config that most closely matches a given descriptor. If there are no matches, this method returns `nullptr`. More...

virtual std::unique_ptr< Context >	CreateContext (const Config &config, const Context *share_context)
	Create a context with a supported config. The supported config can be obtained via a successful call to `ChooseConfig`. More...

virtual std::unique_ptr< Surface >	CreateWindowSurface (const Config &config, EGLNativeWindowType window)
	Create a window surface. The window is an opaque pointer whose value value is platform specific. For instance, ANativeWindow on Android. More...

virtual std::unique_ptr< Surface >	CreatePixelBufferSurface (const Config &config, size_t width, size_t height)
	Create an offscreen pixelbuffer surface. These are of limited use except in the context where applications need to render to a texture in an offscreen context. In such cases, a 1x1 pixel buffer surface is created to obtain a surface that can be used to make the context current on the background thread. More...

const EGLDisplay &	GetHandle () const

Detailed Description

A connection to an EGL display. Only one connection per application instance is sufficient.

The display connection is used to first choose a config from among the available, create a context from that config, and then use that context with a surface on one (and only one) thread at a time.

Definition at line 28 of file display.h.

Constructor & Destructor Documentation

◆ Display()

impeller::egl::Display::Display ( )

Definition at line 16 of file display.cc.

                  {
   EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  
   if (::eglInitialize(display, nullptr, nullptr) != EGL_TRUE) {
     IMPELLER_LOG_EGL_ERROR;
     return;
   }
   display_ = display;
 }

References IMPELLER_LOG_EGL_ERROR.

◆ ~Display()

impeller::egl::Display::~Display ( )

virtual

Definition at line 26 of file display.cc.

                   {
   if (display_ != EGL_NO_DISPLAY) {
     if (::eglTerminate(display_) != EGL_TRUE) {
       IMPELLER_LOG_EGL_ERROR;
     }
   }
 }

References IMPELLER_LOG_EGL_ERROR.

Member Function Documentation

◆ ChooseConfig()

std::unique_ptr< Config > impeller::egl::Display::ChooseConfig ( ConfigDescriptor config ) const

virtual

Choose a config that most closely matches a given descriptor. If there are no matches, this method returns nullptr.

Parameters

[in] config The configuration

Returns: A config that matches a descriptor if one is available. nullptr otherwise.

Definition at line 73 of file display.cc.

                                                                          {
   if (!display_) {
     return nullptr;
   }
  
   std::vector<EGLint> attributes;
  
   {
     attributes.push_back(EGL_RENDERABLE_TYPE);
     switch (config.api) {
       case API::kOpenGL:
         attributes.push_back(EGL_OPENGL_BIT);
         break;
       case API::kOpenGLES2:
         attributes.push_back(EGL_OPENGL_ES2_BIT);
         break;
       case API::kOpenGLES3:
         attributes.push_back(EGL_OPENGL_ES3_BIT);
         break;
     }
   }
  
   {
     attributes.push_back(EGL_SURFACE_TYPE);
     switch (config.surface_type) {
       case SurfaceType::kWindow:
         attributes.push_back(EGL_WINDOW_BIT);
         break;
       case SurfaceType::kPBuffer:
         attributes.push_back(EGL_PBUFFER_BIT);
         break;
     }
   }
  
   {
     switch (config.color_format) {
       case ColorFormat::kRGBA8888:
         attributes.push_back(EGL_RED_SIZE);
         attributes.push_back(8);
         attributes.push_back(EGL_GREEN_SIZE);
         attributes.push_back(8);
         attributes.push_back(EGL_BLUE_SIZE);
         attributes.push_back(8);
         attributes.push_back(EGL_ALPHA_SIZE);
         attributes.push_back(8);
         break;
       case ColorFormat::kRGB565:
         attributes.push_back(EGL_RED_SIZE);
         attributes.push_back(5);
         attributes.push_back(EGL_GREEN_SIZE);
         attributes.push_back(6);
         attributes.push_back(EGL_BLUE_SIZE);
         attributes.push_back(5);
         break;
     }
   }
  
   {
     attributes.push_back(EGL_DEPTH_SIZE);
     attributes.push_back(static_cast<EGLint>(config.depth_bits));
   }
  
   {
     attributes.push_back(EGL_STENCIL_SIZE);
     attributes.push_back(static_cast<EGLint>(config.stencil_bits));
   }
  
   {
     const auto sample_count = static_cast<EGLint>(config.samples);
     if (sample_count > 1) {
       attributes.push_back(EGL_SAMPLE_BUFFERS);
       attributes.push_back(1);
       attributes.push_back(EGL_SAMPLES);
       attributes.push_back(sample_count);
     }
   }
  
   // termination sentinel must be present.
   attributes.push_back(EGL_NONE);
  
   EGLConfig config_out = nullptr;
   EGLint config_count_out = 0;
   if (::eglChooseConfig(display_,           // display
                         attributes.data(),  // attributes (null terminated)
                         &config_out,        // matched configs
                         1,                  // configs array size
                         &config_count_out   // match configs count
                         ) != EGL_TRUE) {
     IMPELLER_LOG_EGL_ERROR;
     return nullptr;
   }
  
   if (config_count_out < 1) {
     return nullptr;
   }
  
   return std::make_unique<Config>(config, config_out);
 }

References impeller::egl::ConfigDescriptor::api, impeller::egl::ConfigDescriptor::color_format, impeller::egl::ConfigDescriptor::depth_bits, IMPELLER_LOG_EGL_ERROR, impeller::egl::kOpenGL, impeller::egl::kOpenGLES2, impeller::egl::kOpenGLES3, impeller::egl::kPBuffer, impeller::egl::kRGB565, impeller::egl::kRGBA8888, impeller::egl::kWindow, impeller::egl::ConfigDescriptor::samples, impeller::egl::ConfigDescriptor::stencil_bits, and impeller::egl::ConfigDescriptor::surface_type.

◆ CreateContext()

std::unique_ptr< Context > impeller::egl::Display::CreateContext	(	const Config &	config,
		const Context *	share_context
	)

virtual

Create a context with a supported config. The supported config can be obtained via a successful call to ChooseConfig.

Parameters

[in]	config	The configuration.
[in]	share_context	The share context. Context within the same share-group use the same handle table. The contexts should still only be used exclusively on each thread however.

Returns: A context if one can be created. nullptr otherwise.

Definition at line 38 of file display.cc.

                                                                               {
   const auto& desc = config.GetDescriptor();
  
   std::vector<EGLint> attributes;
   switch (desc.api) {
     case API::kOpenGL:
       break;
     case API::kOpenGLES2:
       attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
       attributes.push_back(2);
       break;
     case API::kOpenGLES3:
       attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
       attributes.push_back(3);
       break;
   }
   // Termination sentinel must be present.
   attributes.push_back(EGL_NONE);
  
   auto context = ::eglCreateContext(
       display_,            // display
       config.GetHandle(),  // config
       share_context != nullptr ? share_context->GetHandle() : nullptr,  // share
       attributes.data()  // attributes
   );
  
   if (context == EGL_NO_CONTEXT) {
     IMPELLER_LOG_EGL_ERROR;
     return nullptr;
   }
  
   return std::unique_ptr<Context>(new Context(display_, context));
 }

References impeller::egl::Config::GetDescriptor(), impeller::egl::Config::GetHandle(), impeller::egl::Context::GetHandle(), IMPELLER_LOG_EGL_ERROR, impeller::egl::kOpenGL, impeller::egl::kOpenGLES2, and impeller::egl::kOpenGLES3.

◆ CreatePixelBufferSurface()

std::unique_ptr< Surface > impeller::egl::Display::CreatePixelBufferSurface	(	const Config &	config,
		size_t	width,
		size_t	height
	)

virtual

Create an offscreen pixelbuffer surface. These are of limited use except in the context where applications need to render to a texture in an offscreen context. In such cases, a 1x1 pixel buffer surface is created to obtain a surface that can be used to make the context current on the background thread.

Parameters

[in]	config	The configuration
[in]	width	The width
[in]	height	The height

Returns: A valid pixel buffer surface if one can be created. nullptr otherwise.

Definition at line 188 of file display.cc.

                                                                           {
   // clang-format off
   const EGLint attribs[] = {
       EGL_WIDTH,     static_cast<EGLint>(width),
       EGL_HEIGHT,    static_cast<EGLint>(height),
       EGL_NONE
   };
   // clang-format on
   auto surface = ::eglCreatePbufferSurface(display_,            // display
                                            config.GetHandle(),  // config
                                            attribs              // attrib_list
   );
   if (surface == EGL_NO_SURFACE) {
     IMPELLER_LOG_EGL_ERROR;
     return nullptr;
   }
   return std::unique_ptr<Surface>(new Surface(display_, surface));
 }

References impeller::egl::Config::GetHandle(), and IMPELLER_LOG_EGL_ERROR.

◆ CreateWindowSurface()

std::unique_ptr< Surface > impeller::egl::Display::CreateWindowSurface	(	const Config &	config,
		EGLNativeWindowType	window
	)

virtual

Create a window surface. The window is an opaque pointer whose value value is platform specific. For instance, ANativeWindow on Android.

Parameters

[in]	config	A valid configuration. One can be obtained via `ChooseConfig`.
[in]	window	An opaque pointer to a platform specific window handle.

Returns: A valid window surface if one can be created. nullptr otherwise.

Definition at line 172 of file display.cc.

                                 {
   const EGLint attribs[] = {EGL_NONE};
   auto surface = ::eglCreateWindowSurface(display_,            // display
                                           config.GetHandle(),  // config
                                           window,              // window
                                           attribs              // attrib_list
   );
   if (surface == EGL_NO_SURFACE) {
     IMPELLER_LOG_EGL_ERROR;
     return nullptr;
   }
   return std::unique_ptr<Surface>(new Surface(display_, surface));
 }

References impeller::egl::Config::GetHandle(), and IMPELLER_LOG_EGL_ERROR.

◆ GetHandle()

const EGLDisplay & impeller::egl::Display::GetHandle ( ) const

Definition at line 209 of file display.cc.

                                            {
   return display_;
 }

◆ IsValid()

bool impeller::egl::Display::IsValid ( ) const

virtual

Returns: True if the display connection is valid.

Definition at line 34 of file display.cc.

                             {
   return display_ != EGL_NO_DISPLAY;
 }

The documentation for this class was generated from the following files:

impeller/toolkit/egl/display.h
impeller/toolkit/egl/display.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Display()

◆ ~Display()

Member Function Documentation

◆ ChooseConfig()

◆ CreateContext()

◆ CreatePixelBufferSurface()

◆ CreateWindowSurface()

◆ GetHandle()

◆ IsValid()