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`.

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`.

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.

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.

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(), height, IMPELLER_LOG_EGL_ERROR, surface, and width.

◆ 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(), IMPELLER_LOG_EGL_ERROR, surface, and window.

◆ 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()