engine/src/flutter/impeller/toolkit/glvk/trampoline.cc - mirrors/flutter.git - Git at Google

 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "impeller/toolkit/glvk/trampoline.h"

 #include <array>

 #include "flutter/fml/closure.h"
 #include "flutter/fml/trace_event.h"
 #include "impeller/base/timing.h"
 #include "impeller/base/validation.h"
 #include "impeller/geometry/point.h"
 #include "impeller/renderer/backend/gles/formats_gles.h"
 #include "impeller/toolkit/android/proc_table.h"
 #include "impeller/toolkit/egl/image.h"

 namespace impeller::glvk {

 static GLuint kAttributeIndexPosition = 0u;
 static GLuint kAttributeIndexTexCoord = 1u;

 static constexpr const char* kVertShader = R"IMPELLER_SHADER(#version 100

 precision mediump float;

 attribute vec2 aPosition;
 attribute vec2 aTexCoord;

 varying vec2 vTexCoord;

 void main() {
   gl_Position = vec4(aPosition, 0.0, 1.0);
   vTexCoord = aTexCoord;

 }
 )IMPELLER_SHADER";

 static constexpr const char* kFragShader = R"IMPELLER_SHADER(#version 100

 #extension GL_OES_EGL_image_external : require

 precision mediump float;

 uniform samplerExternalOES uTexture;
 uniform mat4 uUVTransformation;

 varying vec2 vTexCoord;

 void main() {
   vec2 texture_coords = (uUVTransformation * vec4(vTexCoord, 0, 1)).xy;
   gl_FragColor = texture2D(uTexture, texture_coords);
 }

 )IMPELLER_SHADER";

 Trampoline::Trampoline() {
   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;
 }

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

 bool Trampoline::IsValid() const {
   return is_valid_;
 }

 static UniqueEGLImageKHR CreateEGLImageFromAHBTexture(
     const EGLDisplay& display,
     const AHBTextureSourceVK& to_texture) {
   if (!android::GetProcTable().eglGetNativeClientBufferANDROID.IsAvailable()) {
     VALIDATION_LOG << "Could not get native client buffer.";
     return {};
   }

   EGLClientBuffer client_buffer =
       android::GetProcTable().eglGetNativeClientBufferANDROID(
           to_texture.GetBackingStore()->GetHandle());

   if (!client_buffer) {
     VALIDATION_LOG
         << "Could not get client buffer from Android hardware buffer.";
     return {};
   }

   auto image = ::eglCreateImageKHR(display,                    //
                                    EGL_NO_CONTEXT,             //
                                    EGL_NATIVE_BUFFER_ANDROID,  //
                                    client_buffer,              //
                                    nullptr                     //
   );
   if (image == NULL) {
     VALIDATION_LOG << "Could not create EGL Image.";
     return {};
   }

   return UniqueEGLImageKHR(EGLImageKHRWithDisplay{image, display});
 }

 bool Trampoline::BlitTextureOpenGLToVulkan(
     const GLTextureInfo& src_texture,
     const AHBTextureSourceVK& dst_texture) const {
   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/flutter/blob/master/docs/engine/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;
 }

 AutoTrampolineContext Trampoline::MakeCurrentContext() const {
   FML_DCHECK(is_valid_);
   return AutoTrampolineContext{*this};
 }

 AutoTrampolineContext::AutoTrampolineContext(const Trampoline& trampoline)
     : context_(trampoline.egl_context_.get()),
       surface_(trampoline.egl_surface_.get()) {
   if (!context_->IsCurrent() && !context_->MakeCurrent(*surface_)) {
     VALIDATION_LOG << "Could not make context current.";
   }
 };

 AutoTrampolineContext::~AutoTrampolineContext() {
   if (!context_->ClearCurrent()) {
     VALIDATION_LOG << "Could not clear current context.";
   }
 }

 }  // namespace impeller::glvk
	// Copyright 2013 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "impeller/toolkit/glvk/trampoline.h"

	#include <array>

	#include "flutter/fml/closure.h"
	#include "flutter/fml/trace_event.h"
	#include "impeller/base/timing.h"
	#include "impeller/base/validation.h"
	#include "impeller/geometry/point.h"
	#include "impeller/renderer/backend/gles/formats_gles.h"
	#include "impeller/toolkit/android/proc_table.h"
	#include "impeller/toolkit/egl/image.h"

	namespace impeller::glvk {

	static GLuint kAttributeIndexPosition = 0u;
	static GLuint kAttributeIndexTexCoord = 1u;

	static constexpr const char* kVertShader = R"IMPELLER_SHADER(#version 100

	precision mediump float;

	attribute vec2 aPosition;
	attribute vec2 aTexCoord;

	varying vec2 vTexCoord;

	void main() {
	gl_Position = vec4(aPosition, 0.0, 1.0);
	vTexCoord = aTexCoord;

	}
	)IMPELLER_SHADER";

	static constexpr const char* kFragShader = R"IMPELLER_SHADER(#version 100

	#extension GL_OES_EGL_image_external : require

	precision mediump float;

	uniform samplerExternalOES uTexture;
	uniform mat4 uUVTransformation;

	varying vec2 vTexCoord;

	void main() {
	vec2 texture_coords = (uUVTransformation * vec4(vTexCoord, 0, 1)).xy;
	gl_FragColor = texture2D(uTexture, texture_coords);
	}

	)IMPELLER_SHADER";

	Trampoline::Trampoline() {
	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;
	}

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

	bool Trampoline::IsValid() const {
	return is_valid_;
	}

	static UniqueEGLImageKHR CreateEGLImageFromAHBTexture(
	const EGLDisplay& display,
	const AHBTextureSourceVK& to_texture) {
	if (!android::GetProcTable().eglGetNativeClientBufferANDROID.IsAvailable()) {
	VALIDATION_LOG << "Could not get native client buffer.";
	return {};
	}

	EGLClientBuffer client_buffer =
	android::GetProcTable().eglGetNativeClientBufferANDROID(
	to_texture.GetBackingStore()->GetHandle());

	if (!client_buffer) {
	VALIDATION_LOG
	<< "Could not get client buffer from Android hardware buffer.";
	return {};
	}

	auto image = ::eglCreateImageKHR(display, //
	EGL_NO_CONTEXT, //
	EGL_NATIVE_BUFFER_ANDROID, //
	client_buffer, //
	nullptr //
	);
	if (image == NULL) {
	VALIDATION_LOG << "Could not create EGL Image.";
	return {};
	}

	return UniqueEGLImageKHR(EGLImageKHRWithDisplay{image, display});
	}

	bool Trampoline::BlitTextureOpenGLToVulkan(
	const GLTextureInfo& src_texture,
	const AHBTextureSourceVK& dst_texture) const {
	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/flutter/blob/master/docs/engine/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;
	}

	AutoTrampolineContext Trampoline::MakeCurrentContext() const {
	FML_DCHECK(is_valid_);
	return AutoTrampolineContext{*this};
	}

	AutoTrampolineContext::AutoTrampolineContext(const Trampoline& trampoline)
	: context_(trampoline.egl_context_.get()),
	surface_(trampoline.egl_surface_.get()) {
	if (!context_->IsCurrent() && !context_->MakeCurrent(*surface_)) {
	VALIDATION_LOG << "Could not make context current.";
	}
	};

	AutoTrampolineContext::~AutoTrampolineContext() {
	if (!context_->ClearCurrent()) {
	VALIDATION_LOG << "Could not clear current context.";
	}
	}

	} // namespace impeller::glvk