impeller::glvk::Trampoline Class Reference

An object used to interoperate between OpenGL and Vulkan. More...

#include <trampoline.h>

Classes
struct	GLTextureInfo
	Describes an OpenGL texture along with information on how to sample from it. More...

Public Member Functions
	Trampoline ()
	Constructs a new trampoline. It is recommended that these objects be cached and reused for all conversion operations. More...
	~Trampoline ()
	Destroys the trampoline. There are no threading restrictions. EGL contexts on already bound to the callers thread may become unbound after a call to this method. More...
	Trampoline (const Trampoline &)=delete
Trampoline &	operator= (const Trampoline &)=delete
bool	IsValid () const
	Determines if this is a valid trampoline. There is no error recovery mechanism if a trampoline cannot be constructed and an invalid trampoline must be immediately discarded. More...
bool	BlitTextureOpenGLToVulkan (const GLTextureInfo &src_texture, const AHBTextureSourceVK &dst_texture) const
	Perform a blit operation from the source OpenGL texture to a target Vulkan texture. More...
AutoTrampolineContext	MakeCurrentContext () const
	Make the EGL context associated with this trampoline current on the calling thread. More...

Friends
class	AutoTrampolineContext

Detailed Description

An object used to interoperate between OpenGL and Vulkan.

        While these are not super expensive to create, they do manage an
        internal EGL context as well as some OpenGL state. For this
        reason, it is recommended that callers cache these for the
        duration of the lifecycle of main rendering context.

Definition at line 27 of file trampoline.h.

Constructor & Destructor Documentation

Trampoline() [1/2]

impeller::glvk::Trampoline::Trampoline

(

)

Constructs a new trampoline. It is recommended that these objects be cached and reused for all conversion operations.

EGL contexts on already bound to the callers thread may become unbound after a call to this method.

Definition at line 57 of file trampoline.cc.

                       {
  auto egl_display = std::make_unique<egl::Display>();
  if (!egl_display->IsValid()) {
    VALIDATION_LOG
        << "Could not create EGL display for external texture interop.";
    return;
  }
 
  egl::ConfigDescriptor egl_config_desc;
  egl_config_desc.api = egl::API::kOpenGLES2;
  egl_config_desc.samples = egl::Samples::kOne;
  egl_config_desc.color_format = egl::ColorFormat::kRGBA8888;
  egl_config_desc.stencil_bits = egl::StencilBits::kZero;
  egl_config_desc.depth_bits = egl::DepthBits::kZero;
  egl_config_desc.surface_type = egl::SurfaceType::kPBuffer;
  auto egl_config = egl_display->ChooseConfig(egl_config_desc);
  if (!egl_config) {
    VALIDATION_LOG
        << "Could not choose EGL config for external texture interop.";
    return;
  }
 
  auto egl_surface = egl_display->CreatePixelBufferSurface(*egl_config, 1u, 1u);
  auto egl_context = egl_display->CreateContext(*egl_config, nullptr);
 
  if (!egl_surface || !egl_context) {
    VALIDATION_LOG << "Could not create EGL surface and/or context for "
                      "external texture interop.";
    return;
  }
 
  // Make the context current so the proc addresses can be resolved.
  if (!egl_context->MakeCurrent(*egl_surface)) {
    VALIDATION_LOG << "Could not make the context current.";
    return;
  }
 
  auto gl = std::make_unique<ProcTable>(egl::CreateProcAddressResolver());
 
  if (!gl->IsValid()) {
    egl_context->ClearCurrent();
    VALIDATION_LOG << "Could not setup trampoline proc table.";
    return;
  }
 
  // Generate program object.
  auto vert_shader = gl->CreateShader(GL_VERTEX_SHADER);
  auto frag_shader = gl->CreateShader(GL_FRAGMENT_SHADER);
 
  GLint vert_shader_size = strlen(kVertShader);
  GLint frag_shader_size = strlen(kFragShader);
 
  gl->ShaderSource(vert_shader, 1u, &kVertShader, &vert_shader_size);
  gl->ShaderSource(frag_shader, 1u, &kFragShader, &frag_shader_size);
 
  gl->CompileShader(vert_shader);
  gl->CompileShader(frag_shader);
 
  GLint vert_status = GL_FALSE;
  GLint frag_status = GL_FALSE;
 
  gl->GetShaderiv(vert_shader, GL_COMPILE_STATUS, &vert_status);
  gl->GetShaderiv(frag_shader, GL_COMPILE_STATUS, &frag_status);
 
  FML_CHECK(vert_status == GL_TRUE);
  FML_CHECK(frag_status == GL_TRUE);
 
  program_ = gl->CreateProgram();
  gl->AttachShader(program_, vert_shader);
  gl->AttachShader(program_, frag_shader);
 
  gl->BindAttribLocation(program_, kAttributeIndexPosition, "aPosition");
  gl->BindAttribLocation(program_, kAttributeIndexTexCoord, "aTexCoord");
 
  gl->LinkProgram(program_);
 
  GLint link_status = GL_FALSE;
  gl->GetProgramiv(program_, GL_LINK_STATUS, &link_status);
  FML_CHECK(link_status == GL_TRUE);
 
  texture_uniform_location_ = gl->GetUniformLocation(program_, "uTexture");
  uv_transformation_location_ =
      gl->GetUniformLocation(program_, "uUVTransformation");
 
  gl->DeleteShader(vert_shader);
  gl->DeleteShader(frag_shader);
 
  egl_context->ClearCurrent();
 
  gl_ = std::move(gl);
  egl_display_ = std::move(egl_display);
  egl_context_ = std::move(egl_context);
  egl_surface_ = std::move(egl_surface);
  is_valid_ = true;
}

References impeller::egl::ConfigDescriptor::api, impeller::egl::ConfigDescriptor::color_format, impeller::egl::CreateProcAddressResolver(), impeller::egl::ConfigDescriptor::depth_bits, impeller::glvk::kAttributeIndexPosition, impeller::glvk::kAttributeIndexTexCoord, impeller::glvk::kFragShader, impeller::egl::kOne, impeller::egl::kOpenGLES2, impeller::egl::kPBuffer, impeller::egl::kRGBA8888, impeller::glvk::kVertShader, impeller::egl::kZero, impeller::egl::ConfigDescriptor::samples, impeller::egl::ConfigDescriptor::stencil_bits, impeller::egl::ConfigDescriptor::surface_type, and VALIDATION_LOG.

~Trampoline()

impeller::glvk::Trampoline::~Trampoline

(

)

Destroys the trampoline. There are no threading restrictions. EGL contexts on already bound to the callers thread may become unbound after a call to this method.

Definition at line 153 of file trampoline.cc.

                        {
  if (!is_valid_) {
    return;
  }
  auto context = MakeCurrentContext();
  gl_->DeleteProgram(program_);
}

References MakeCurrentContext().

Trampoline() [2/2]

impeller::glvk::Trampoline::Trampoline ( const Trampoline &  )

delete

Member Function Documentation

BlitTextureOpenGLToVulkan()

bool impeller::glvk::Trampoline::BlitTextureOpenGLToVulkan	(	const GLTextureInfo &	src_texture,
		const AHBTextureSourceVK &	dst_texture
	)		const

Perform a blit operation from the source OpenGL texture to a target Vulkan texture.

It is the callers responsibility to ensure that the EGL context associated with the trampoline is already current before making this call.

It is also the responsibility of the caller to ensure that the destination texture is the color-attachment-optimal layout. Failure to ensure this will lead to validation error.

See also

MakeCurrentContext

Parameters

[in]	src_texture	The source OpenGL texture.
[in]	dst_texture	The destination Vulkan texture.

Returns

True if the blit was successful, False otherwise.

Definition at line 197 of file trampoline.cc.

                                                 {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!is_valid_) {
    return false;
  }
 
  FML_DCHECK(egl_context_->IsCurrent());
 
  auto dst_egl_image =
      CreateEGLImageFromAHBTexture(egl_display_->GetHandle(), dst_texture);
  if (!dst_egl_image.is_valid()) {
    VALIDATION_LOG << "Could not create EGL image from AHB texture.";
    return false;
  }
 
  const auto& gl = *gl_;
 
  GLuint dst_gl_texture = GL_NONE;
  gl.GenTextures(1u, &dst_gl_texture);
  gl.BindTexture(GL_TEXTURE_2D, dst_gl_texture);
  gl.EGLImageTargetTexture2DOES(GL_TEXTURE_2D, dst_egl_image.get().image);
 
  GLuint offscreen_fbo = GL_NONE;
  gl.GenFramebuffers(1u, &offscreen_fbo);
  gl.BindFramebuffer(GL_FRAMEBUFFER, offscreen_fbo);
  gl.FramebufferTexture2D(GL_FRAMEBUFFER,        //
                          GL_COLOR_ATTACHMENT0,  //
                          GL_TEXTURE_2D,         //
                          dst_gl_texture,        //
                          0                      //
  );
 
  FML_CHECK(gl.CheckFramebufferStatus(GL_FRAMEBUFFER) ==
            GL_FRAMEBUFFER_COMPLETE);
 
  gl.Disable(GL_BLEND);
  gl.Disable(GL_SCISSOR_TEST);
  gl.Disable(GL_DITHER);
  gl.Disable(GL_CULL_FACE);
  gl.ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
  gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  gl.Clear(GL_COLOR_BUFFER_BIT);
 
  const auto& fb_size = dst_texture.GetTextureDescriptor().size;
  gl.Viewport(0, 0, fb_size.width, fb_size.height);
 
  gl.UseProgram(program_);
 
  struct VertexData {
    Point position;
    Point tex_coord;
  };
 
  // The vertex coordinates assume OpenGL NDC because that's the API we are
  // using to draw the quad. But the texture will be sampled in Vulkan so the
  // texture coordinate system assumes Vulkan convention.
  //
  // See the following help link for an overview of the different coordinate
  // systems:
  // https://github.com/flutter/engine/blob/5810b3fc791f4bb82b9a454014310990eddc1181/impeller/docs/coordinate_system.md
  static constexpr const VertexData kVertData[] = {
      {{-1, -1}, {0, 1}},  // bottom left
      {{-1, +1}, {0, 0}},  // top left
      {{+1, +1}, {1, 0}},  // top right
      {{+1, -1}, {1, 1}},  // bottom right
  };
 
  // This is tedious but we assume no vertex array objects (VAO) are available
  // because of ES 2 versioning constraints.
  GLuint vertex_buffer = GL_NONE;
  gl.GenBuffers(1u, &vertex_buffer);
  gl.BindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
  gl.BufferData(GL_ARRAY_BUFFER, sizeof(kVertData), kVertData, GL_STATIC_DRAW);
  gl.EnableVertexAttribArray(kAttributeIndexPosition);
  gl.EnableVertexAttribArray(kAttributeIndexTexCoord);
  gl.VertexAttribPointer(
      kAttributeIndexPosition, 2, GL_FLOAT, GL_FALSE, sizeof(VertexData),
      reinterpret_cast<void*>(offsetof(VertexData, position)));
  gl.VertexAttribPointer(
      kAttributeIndexTexCoord, 2, GL_FLOAT, GL_FALSE, sizeof(VertexData),
      reinterpret_cast<void*>(offsetof(VertexData, tex_coord)));
 
  gl.ActiveTexture(GL_TEXTURE0);
  gl.BindTexture(src_texture.target, src_texture.texture);
  gl.TexParameteri(src_texture.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  gl.TexParameteri(src_texture.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  gl.TexParameteri(src_texture.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  gl.TexParameteri(src_texture.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  gl.Uniform1i(texture_uniform_location_, 0u);
 
  auto gl_uv_transformation = src_texture.uv_transformation;
 
  gl.UniformMatrix4fv(uv_transformation_location_, 1u, GL_FALSE,
                      reinterpret_cast<GLfloat*>(&gl_uv_transformation));
 
  gl.DrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
  gl.UseProgram(GL_NONE);
 
  gl.Flush();
 
  gl.DeleteFramebuffers(1u, &offscreen_fbo);
  gl.DeleteTextures(1u, &dst_gl_texture);
  gl.DeleteBuffers(1u, &vertex_buffer);
 
  // Theoretically, this does nothing because the surface is a 1x1 pbuffer
  // surface. But frame capture tools use this to denote a frame boundary in
  // OpenGL. So add this as a debugging aid anyway.
  eglSwapBuffers(egl_display_->GetHandle(), egl_surface_->GetHandle());
 
  return true;
}

References impeller::glvk::CreateEGLImageFromAHBTexture(), impeller::TextureSourceVK::GetTextureDescriptor(), impeller::glvk::kAttributeIndexPosition, impeller::glvk::kAttributeIndexTexCoord, impeller::TextureDescriptor::size, impeller::glvk::Trampoline::GLTextureInfo::target, impeller::glvk::Trampoline::GLTextureInfo::texture, impeller::glvk::Trampoline::GLTextureInfo::uv_transformation, and VALIDATION_LOG.

IsValid()

bool impeller::glvk::Trampoline::IsValid

(

)

const

Determines if this is a valid trampoline. There is no error recovery mechanism if a trampoline cannot be constructed and an invalid trampoline must be immediately discarded.

Returns

True if valid, False otherwise.

Definition at line 161 of file trampoline.cc.

                               {
  return is_valid_;
}

MakeCurrentContext()

AutoTrampolineContext impeller::glvk::Trampoline::MakeCurrentContext

(

)

const

Make the EGL context associated with this trampoline current on the calling thread.

Returns

The automatic trampoline context. The collection of this context clears the threads EGL binding.

Definition at line 313 of file trampoline.cc.

                                                           {
  FML_DCHECK(is_valid_);
  return AutoTrampolineContext{*this};
}

Referenced by ~Trampoline().

operator=()

Trampoline& impeller::glvk::Trampoline::operator= ( const Trampoline &  )

delete

Friends And Related Function Documentation

AutoTrampolineContext

friend class AutoTrampolineContext

friend

Definition at line 111 of file trampoline.h.

---

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

• impeller/toolkit/glvk/trampoline.h
• impeller/toolkit/glvk/trampoline.cc