Flutter Impeller
impeller::Playground Class Referenceabstract

#include <playground.h>

Inheritance diagram for impeller::Playground:
impeller::ComputePlaygroundTest impeller::PlaygroundTest impeller::AiksPlayground impeller::DlPlayground impeller::EntityPlayground impeller::RuntimeStagePlayground impeller::interop::testing::PlaygroundTest impeller::testing::RendererDartTest impeller::testing::BlendFilterContentsTest impeller::testing::GaussianBlurFilterContentsTest impeller::testing::MatrixFilterContentsTest

Public Types

using SinglePassCallback = std::function< bool(RenderPass &pass)>
 
using RenderCallback = std::function< bool(RenderTarget &render_target)>
 
using GLProcAddressResolver = std::function< void *(const char *proc_name)>
 
using VKProcAddressResolver = std::function< void *(void *instance, const char *proc_name)>
 

Public Member Functions

 Playground (PlaygroundSwitches switches)
 
virtual ~Playground ()
 
void SetupContext (PlaygroundBackend backend, const PlaygroundSwitches &switches)
 
void SetupWindow ()
 
void TeardownWindow ()
 
bool IsPlaygroundEnabled () const
 
Point GetCursorPosition () const
 
ISize GetWindowSize () const
 
Point GetContentScale () const
 
Scalar GetSecondsElapsed () const
 Get the amount of time elapsed from the start of the playground's execution. More...
 
std::shared_ptr< ContextGetContext () const
 
std::shared_ptr< ContextMakeContext () const
 
bool OpenPlaygroundHere (const RenderCallback &render_callback)
 
bool OpenPlaygroundHere (SinglePassCallback pass_callback)
 
std::shared_ptr< TextureCreateTextureForFixture (const char *fixture_name, bool enable_mipmapping=false) const
 
std::shared_ptr< TextureCreateTextureCubeForFixture (std::array< const char *, 6 > fixture_names) const
 
virtual std::unique_ptr< fml::Mapping > OpenAssetAsMapping (std::string asset_name) const =0
 
virtual std::string GetWindowTitle () const =0
 
fml::Status SetCapabilities (const std::shared_ptr< Capabilities > &capabilities)
 
bool WillRenderSomething () const
 Returns true if OpenPlaygroundHere will actually render anything. More...
 
GLProcAddressResolver CreateGLProcAddressResolver () const
 
VKProcAddressResolver CreateVKProcAddressResolver () const
 
void SetGPUDisabled (bool disabled) const
 Mark the GPU as unavilable. More...
 

Static Public Member Functions

static bool ShouldOpenNewPlaygrounds ()
 
static std::shared_ptr< CompressedImageLoadFixtureImageCompressed (std::shared_ptr< fml::Mapping > mapping)
 
static std::optional< DecompressedImageDecodeImageRGBA (const std::shared_ptr< CompressedImage > &compressed)
 
static std::shared_ptr< TextureCreateTextureForMapping (const std::shared_ptr< Context > &context, std::shared_ptr< fml::Mapping > mapping, bool enable_mipmapping=false)
 
static bool SupportsBackend (PlaygroundBackend backend)
 

Protected Member Functions

virtual bool ShouldKeepRendering () const
 
void SetWindowSize (ISize size)
 

Protected Attributes

const PlaygroundSwitches switches_
 

Detailed Description

Definition at line 48 of file playground.h.

Member Typedef Documentation

◆ GLProcAddressResolver

using impeller::Playground::GLProcAddressResolver = std::function<void*(const char* proc_name)>

Definition at line 118 of file playground.h.

◆ RenderCallback

using impeller::Playground::RenderCallback = std::function<bool(RenderTarget& render_target)>

Definition at line 81 of file playground.h.

◆ SinglePassCallback

using impeller::Playground::SinglePassCallback = std::function<bool(RenderPass& pass)>

Definition at line 50 of file playground.h.

◆ VKProcAddressResolver

using impeller::Playground::VKProcAddressResolver = std::function<void*(void* instance, const char* proc_name)>

Definition at line 121 of file playground.h.

Constructor & Destructor Documentation

◆ Playground()

impeller::Playground::Playground ( PlaygroundSwitches  switches)
explicit

Definition at line 84 of file playground.cc.

84  : switches_(switches) {
87 }
const PlaygroundSwitches switches_
Definition: playground.h:131
static void InitializeGLFWOnce()
Definition: playground.cc:58
void SetupSwiftshaderOnce(bool use_swiftshader)
Find and setup the installable client driver for a locally built SwiftShader at known paths....

References impeller::InitializeGLFWOnce(), impeller::SetupSwiftshaderOnce(), switches_, and impeller::PlaygroundSwitches::use_swiftshader.

◆ ~Playground()

impeller::Playground::~Playground ( )
virtualdefault

Member Function Documentation

◆ CreateGLProcAddressResolver()

Playground::GLProcAddressResolver impeller::Playground::CreateGLProcAddressResolver ( ) const

Definition at line 520 of file playground.cc.

521  {
522  return impl_->CreateGLProcAddressResolver();
523 }

Referenced by impeller::interop::testing::PlaygroundTest::CreateContext().

◆ CreateTextureCubeForFixture()

std::shared_ptr< Texture > impeller::Playground::CreateTextureCubeForFixture ( std::array< const char *, 6 >  fixture_names) const

Definition at line 458 of file playground.cc.

459  {
460  std::array<DecompressedImage, 6> images;
461  for (size_t i = 0; i < fixture_names.size(); i++) {
462  auto image = DecodeImageRGBA(
464  if (!image.has_value()) {
465  return nullptr;
466  }
467  images[i] = image.value();
468  }
469 
470  TextureDescriptor texture_descriptor;
471  texture_descriptor.storage_mode = StorageMode::kDevicePrivate;
472  texture_descriptor.type = TextureType::kTextureCube;
473  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
474  texture_descriptor.size = images[0].GetSize();
475  texture_descriptor.mip_count = 1u;
476 
477  auto texture =
478  context_->GetResourceAllocator()->CreateTexture(texture_descriptor);
479  if (!texture) {
480  VALIDATION_LOG << "Could not allocate texture cube.";
481  return nullptr;
482  }
483  texture->SetLabel("Texture cube");
484 
485  auto cmd_buffer = context_->CreateCommandBuffer();
486  auto blit_pass = cmd_buffer->CreateBlitPass();
487  for (size_t i = 0; i < fixture_names.size(); i++) {
488  auto device_buffer = context_->GetResourceAllocator()->CreateBufferWithCopy(
489  *images[i].GetAllocation());
490  blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer), texture, {},
491  "", /*mip_level=*/0, /*slice=*/i);
492  }
493 
494  if (!blit_pass->EncodeCommands() ||
495  !context_->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok()) {
496  VALIDATION_LOG << "Could not upload texture to device memory.";
497  return nullptr;
498  }
499 
500  return texture;
501 }
static BufferView AsBufferView(std::shared_ptr< DeviceBuffer > buffer)
Create a buffer view of this entire buffer.
static std::shared_ptr< CompressedImage > LoadFixtureImageCompressed(std::shared_ptr< fml::Mapping > mapping)
Definition: playground.cc:361
virtual std::unique_ptr< fml::Mapping > OpenAssetAsMapping(std::string asset_name) const =0
static std::optional< DecompressedImage > DecodeImageRGBA(const std::shared_ptr< CompressedImage > &compressed)
Definition: playground.cc:372
#define VALIDATION_LOG
Definition: validation.h:91

References impeller::DeviceBuffer::AsBufferView(), DecodeImageRGBA(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kTextureCube, LoadFixtureImageCompressed(), impeller::TextureDescriptor::mip_count, OpenAssetAsMapping(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::TextureDescriptor::type, and VALIDATION_LOG.

◆ CreateTextureForFixture()

std::shared_ptr< Texture > impeller::Playground::CreateTextureForFixture ( const char *  fixture_name,
bool  enable_mipmapping = false 
) const

Definition at line 446 of file playground.cc.

448  {
449  auto texture = CreateTextureForMapping(
450  context_, OpenAssetAsMapping(fixture_name), enable_mipmapping);
451  if (texture == nullptr) {
452  return nullptr;
453  }
454  texture->SetLabel(fixture_name);
455  return texture;
456 }
static std::shared_ptr< Texture > CreateTextureForMapping(const std::shared_ptr< Context > &context, std::shared_ptr< fml::Mapping > mapping, bool enable_mipmapping=false)
Definition: playground.cc:433

References CreateTextureForMapping(), and OpenAssetAsMapping().

◆ CreateTextureForMapping()

std::shared_ptr< Texture > impeller::Playground::CreateTextureForMapping ( const std::shared_ptr< Context > &  context,
std::shared_ptr< fml::Mapping >  mapping,
bool  enable_mipmapping = false 
)
static

Definition at line 433 of file playground.cc.

436  {
437  auto image = Playground::DecodeImageRGBA(
438  Playground::LoadFixtureImageCompressed(std::move(mapping)));
439  if (!image.has_value()) {
440  return nullptr;
441  }
442  return CreateTextureForDecompressedImage(context, image.value(),
443  enable_mipmapping);
444 }
static std::shared_ptr< Texture > CreateTextureForDecompressedImage(const std::shared_ptr< Context > &context, DecompressedImage &decompressed_image, bool enable_mipmapping)
Definition: playground.cc:391

References impeller::CreateTextureForDecompressedImage(), DecodeImageRGBA(), and LoadFixtureImageCompressed().

Referenced by impeller::DlPlayground::CreateDlImageForFixture(), impeller::GoldenPlaygroundTest::CreateTextureForFixture(), and CreateTextureForFixture().

◆ CreateVKProcAddressResolver()

Playground::VKProcAddressResolver impeller::Playground::CreateVKProcAddressResolver ( ) const

Definition at line 525 of file playground.cc.

526  {
527  return impl_->CreateVKProcAddressResolver();
528 }

Referenced by impeller::interop::testing::PlaygroundTest::CreateContext().

◆ DecodeImageRGBA()

std::optional< DecompressedImage > impeller::Playground::DecodeImageRGBA ( const std::shared_ptr< CompressedImage > &  compressed)
static

Definition at line 372 of file playground.cc.

373  {
374  if (compressed == nullptr) {
375  return std::nullopt;
376  }
377  // The decoded image is immediately converted into RGBA as that format is
378  // known to be supported everywhere. For image sources that don't need 32
379  // bit pixel strides, this is overkill. Since this is a test fixture we
380  // aren't necessarily trying to eke out memory savings here and instead
381  // favor simplicity.
382  auto image = compressed->Decode().ConvertToRGBA();
383  if (!image.IsValid()) {
384  VALIDATION_LOG << "Could not decode image.";
385  return std::nullopt;
386  }
387 
388  return image;
389 }

References VALIDATION_LOG.

Referenced by CreateTextureCubeForFixture(), CreateTextureForMapping(), and impeller::interop::testing::PlaygroundTest::OpenAssetAsHPPTexture().

◆ GetContentScale()

Point impeller::Playground::GetContentScale ( ) const

◆ GetContext()

◆ GetCursorPosition()

Point impeller::Playground::GetCursorPosition ( ) const

Definition at line 181 of file playground.cc.

181  {
182  return cursor_position_;
183 }

◆ GetSecondsElapsed()

Scalar impeller::Playground::GetSecondsElapsed ( ) const

Get the amount of time elapsed from the start of the playground's execution.

Definition at line 193 of file playground.cc.

193  {
194  return (fml::TimePoint::Now().ToEpochDelta() - start_time_).ToSecondsF();
195 }

◆ GetWindowSize()

ISize impeller::Playground::GetWindowSize ( ) const

◆ GetWindowTitle()

virtual std::string impeller::Playground::GetWindowTitle ( ) const
pure virtual

◆ IsPlaygroundEnabled()

bool impeller::Playground::IsPlaygroundEnabled ( ) const

◆ LoadFixtureImageCompressed()

std::shared_ptr< CompressedImage > impeller::Playground::LoadFixtureImageCompressed ( std::shared_ptr< fml::Mapping >  mapping)
static

Definition at line 361 of file playground.cc.

362  {
363  auto compressed_image = CompressedImageSkia::Create(std::move(mapping));
364  if (!compressed_image) {
365  VALIDATION_LOG << "Could not create compressed image.";
366  return nullptr;
367  }
368 
369  return compressed_image;
370 }
static std::shared_ptr< CompressedImage > Create(std::shared_ptr< const fml::Mapping > allocation)

References impeller::CompressedImageSkia::Create(), and VALIDATION_LOG.

Referenced by CreateTextureCubeForFixture(), CreateTextureForMapping(), and impeller::interop::testing::PlaygroundTest::OpenAssetAsHPPTexture().

◆ MakeContext()

std::shared_ptr< Context > impeller::Playground::MakeContext ( ) const

Definition at line 95 of file playground.cc.

95  {
96  // Playgrounds are already making a context for each test, so we can just
97  // return the `context_`.
98  return context_;
99 }

◆ OpenAssetAsMapping()

virtual std::unique_ptr<fml::Mapping> impeller::Playground::OpenAssetAsMapping ( std::string  asset_name) const
pure virtual

◆ OpenPlaygroundHere() [1/2]

bool impeller::Playground::OpenPlaygroundHere ( const RenderCallback render_callback)

Definition at line 201 of file playground.cc.

202  {
204  return true;
205  }
206 
207  if (!render_callback) {
208  return true;
209  }
210 
211  IMGUI_CHECKVERSION();
213  fml::ScopedCleanupClosure destroy_imgui_context(
214  []() { ImGui::DestroyContext(); });
215  ImGui::StyleColorsDark();
216 
217  auto& io = ImGui::GetIO();
218  io.IniFilename = nullptr;
219  io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
220  io.ConfigWindowsResizeFromEdges = true;
221 
222  auto window = reinterpret_cast<GLFWwindow*>(impl_->GetWindowHandle());
223  if (!window) {
224  return false;
225  }
226  ::glfwSetWindowTitle(window, GetWindowTitle().c_str());
227  ::glfwSetWindowUserPointer(window, this);
228  ::glfwSetWindowSizeCallback(
229  window, [](GLFWwindow* window, int width, int height) -> void {
230  auto playground =
231  reinterpret_cast<Playground*>(::glfwGetWindowUserPointer(window));
232  if (!playground) {
233  return;
234  }
235  playground->SetWindowSize(ISize{width, height}.Max({}));
236  });
237  ::glfwSetKeyCallback(window, &PlaygroundKeyCallback);
238  ::glfwSetCursorPosCallback(window, [](GLFWwindow* window, double x,
239  double y) {
240  reinterpret_cast<Playground*>(::glfwGetWindowUserPointer(window))
241  ->SetCursorPosition({static_cast<Scalar>(x), static_cast<Scalar>(y)});
242  });
243 
244  ImGui_ImplGlfw_InitForOther(window, true);
245  fml::ScopedCleanupClosure shutdown_imgui([]() { ImGui_ImplGlfw_Shutdown(); });
246 
247  ImGui_ImplImpeller_Init(context_);
248  fml::ScopedCleanupClosure shutdown_imgui_impeller(
249  []() { ImGui_ImplImpeller_Shutdown(); });
250 
251  ImGui::SetNextWindowPos({10, 10});
252 
253  ::glfwSetWindowSize(window, GetWindowSize().width, GetWindowSize().height);
254  ::glfwSetWindowPos(window, 200, 100);
255  ::glfwShowWindow(window);
256 
257  while (true) {
258 #if FML_OS_MACOSX
259  fml::ScopedNSAutoreleasePool pool;
260 #endif
261  ::glfwPollEvents();
262 
263  if (::glfwWindowShouldClose(window)) {
264  return true;
265  }
266 
267  ImGui_ImplGlfw_NewFrame();
268 
269  auto surface = impl_->AcquireSurfaceFrame(context_);
270  RenderTarget render_target = surface->GetRenderTarget();
271 
272  ImGui::NewFrame();
273  ImGui::DockSpaceOverViewport(ImGui::GetMainViewport(),
274  ImGuiDockNodeFlags_PassthruCentralNode);
275  bool result = render_callback(render_target);
276  ImGui::Render();
277 
278  // Render ImGui overlay.
279  {
280  auto buffer = context_->CreateCommandBuffer();
281  if (!buffer) {
282  VALIDATION_LOG << "Could not create command buffer.";
283  return false;
284  }
285  buffer->SetLabel("ImGui Command Buffer");
286 
287  auto color0 = render_target.GetColorAttachment(0);
288  color0.load_action = LoadAction::kLoad;
289  if (color0.resolve_texture) {
290  color0.texture = color0.resolve_texture;
291  color0.resolve_texture = nullptr;
292  color0.store_action = StoreAction::kStore;
293  }
294  render_target.SetColorAttachment(color0, 0);
295  render_target.SetStencilAttachment(std::nullopt);
296  render_target.SetDepthAttachment(std::nullopt);
297 
298  auto pass = buffer->CreateRenderPass(render_target);
299  if (!pass) {
300  VALIDATION_LOG << "Could not create render pass.";
301  return false;
302  }
303  pass->SetLabel("ImGui Render Pass");
304  if (!host_buffer_) {
305  host_buffer_ = HostBuffer::Create(
306  context_->GetResourceAllocator(), context_->GetIdleWaiter(),
307  context_->GetCapabilities()->GetMinimumUniformAlignment());
308  }
309 
310  ImGui_ImplImpeller_RenderDrawData(ImGui::GetDrawData(), *pass,
311  *host_buffer_);
312 
313  pass->EncodeCommands();
314 
315  if (!context_->GetCommandQueue()->Submit({buffer}).ok()) {
316  return false;
317  }
318  }
319 
320  if (!result || !surface->Present()) {
321  return false;
322  }
323 
324  if (!ShouldKeepRendering()) {
325  break;
326  }
327  }
328 
329  ::glfwHideWindow(window);
330 
331  return true;
332 }
static std::shared_ptr< HostBuffer > Create(const std::shared_ptr< Allocator > &allocator, const std::shared_ptr< const IdleWaiter > &idle_waiter, size_t minimum_uniform_alignment)
Definition: host_buffer.cc:21
Playground(PlaygroundSwitches switches)
Definition: playground.cc:84
virtual bool ShouldKeepRendering() const
Definition: playground.cc:507
ISize GetWindowSize() const
Definition: playground.cc:185
virtual std::string GetWindowTitle() const =0
int32_t x
void ImGui_ImplImpeller_RenderDrawData(ImDrawData *draw_data, impeller::RenderPass &render_pass, impeller::HostBuffer &host_buffer)
bool ImGui_ImplImpeller_Init(const std::shared_ptr< impeller::Context > &context)
void ImGui_ImplImpeller_Shutdown()
std::shared_ptr< Context > CreateContext()
float Scalar
Definition: scalar.h:19
static void PlaygroundKeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
Definition: playground.cc:168
ISize64 ISize
Definition: size.h:162
constexpr TSize Max(const TSize &o) const
Definition: size.h:97

References impeller::HostBuffer::Create(), impeller::android::testing::CreateContext(), impeller::PlaygroundSwitches::enable_playground, impeller::RenderTarget::GetColorAttachment(), GetWindowSize(), GetWindowTitle(), ImGui_ImplImpeller_Init(), ImGui_ImplImpeller_RenderDrawData(), ImGui_ImplImpeller_Shutdown(), impeller::kLoad, impeller::kStore, impeller::Attachment::load_action, impeller::TSize< T >::Max(), impeller::PlaygroundKeyCallback(), impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetDepthAttachment(), impeller::RenderTarget::SetStencilAttachment(), SetWindowSize(), ShouldKeepRendering(), switches_, VALIDATION_LOG, and x.

Referenced by impeller::AiksPlayground::OpenPlaygroundHere(), impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::interop::testing::PlaygroundTest::OpenPlaygroundHere(), OpenPlaygroundHere(), impeller::testing::RendererDartTest::RenderDartToPlayground(), and impeller::testing::TEST_P().

◆ OpenPlaygroundHere() [2/2]

bool impeller::Playground::OpenPlaygroundHere ( SinglePassCallback  pass_callback)

Definition at line 334 of file playground.cc.

334  {
335  return OpenPlaygroundHere(
336  [context = GetContext(), &pass_callback](RenderTarget& render_target) {
337  auto buffer = context->CreateCommandBuffer();
338  if (!buffer) {
339  return false;
340  }
341  buffer->SetLabel("Playground Command Buffer");
342 
343  auto pass = buffer->CreateRenderPass(render_target);
344  if (!pass) {
345  return false;
346  }
347  pass->SetLabel("Playground Render Pass");
348 
349  if (!pass_callback(*pass)) {
350  return false;
351  }
352 
353  pass->EncodeCommands();
354  if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
355  return false;
356  }
357  return true;
358  });
359 }
bool OpenPlaygroundHere(const RenderCallback &render_callback)
Definition: playground.cc:201
std::shared_ptr< Context > GetContext() const
Definition: playground.cc:91

References GetContext(), and OpenPlaygroundHere().

◆ SetCapabilities()

fml::Status impeller::Playground::SetCapabilities ( const std::shared_ptr< Capabilities > &  capabilities)

Definition at line 511 of file playground.cc.

512  {
513  return impl_->SetCapabilities(capabilities);
514 }

◆ SetGPUDisabled()

void impeller::Playground::SetGPUDisabled ( bool  disabled) const

Mark the GPU as unavilable.

Only supported on the Metal backend.

Definition at line 530 of file playground.cc.

530  {
531  impl_->SetGPUDisabled(value);
532 }
int32_t value

References value.

◆ SetupContext()

void impeller::Playground::SetupContext ( PlaygroundBackend  backend,
const PlaygroundSwitches switches 
)

Definition at line 125 of file playground.cc.

126  {
127  FML_CHECK(SupportsBackend(backend));
128 
129  impl_ = PlaygroundImpl::Create(backend, switches);
130  if (!impl_) {
131  FML_LOG(WARNING) << "PlaygroundImpl::Create failed.";
132  return;
133  }
134 
135  context_ = impl_->GetContext();
136 }
static bool SupportsBackend(PlaygroundBackend backend)
Definition: playground.cc:101
static std::unique_ptr< PlaygroundImpl > Create(PlaygroundBackend backend, PlaygroundSwitches switches)

References impeller::PlaygroundImpl::Create(), and SupportsBackend().

Referenced by impeller::ComputePlaygroundTest::SetUp(), and impeller::PlaygroundTest::SetUp().

◆ SetupWindow()

void impeller::Playground::SetupWindow ( )

Definition at line 138 of file playground.cc.

138  {
139  if (!context_) {
140  FML_LOG(WARNING) << "Asked to set up a window with no context (call "
141  "SetupContext first).";
142  return;
143  }
144  start_time_ = fml::TimePoint::Now().ToEpochDelta();
145 }

Referenced by impeller::ComputePlaygroundTest::SetUp(), and impeller::PlaygroundTest::SetUp().

◆ SetWindowSize()

void impeller::Playground::SetWindowSize ( ISize  size)
protected

Definition at line 503 of file playground.cc.

503  {
504  window_size_ = size;
505 }

Referenced by OpenPlaygroundHere().

◆ ShouldKeepRendering()

bool impeller::Playground::ShouldKeepRendering ( ) const
protectedvirtual

Definition at line 507 of file playground.cc.

507  {
508  return true;
509 }

Referenced by OpenPlaygroundHere().

◆ ShouldOpenNewPlaygrounds()

bool impeller::Playground::ShouldOpenNewPlaygrounds ( )
static

Definition at line 164 of file playground.cc.

164  {
166 }
static std::atomic_bool gShouldOpenNewPlaygrounds
Definition: playground.cc:162

References impeller::gShouldOpenNewPlaygrounds.

Referenced by impeller::ComputePlaygroundTest::SetUp(), and impeller::PlaygroundTest::SetUp().

◆ SupportsBackend()

bool impeller::Playground::SupportsBackend ( PlaygroundBackend  backend)
static

Definition at line 101 of file playground.cc.

101  {
102  switch (backend) {
104 #if IMPELLER_ENABLE_METAL
105  return true;
106 #else // IMPELLER_ENABLE_METAL
107  return false;
108 #endif // IMPELLER_ENABLE_METAL
110 #if IMPELLER_ENABLE_OPENGLES
111  return true;
112 #else // IMPELLER_ENABLE_OPENGLES
113  return false;
114 #endif // IMPELLER_ENABLE_OPENGLES
116 #if IMPELLER_ENABLE_VULKAN
118 #else // IMPELLER_ENABLE_VULKAN
119  return false;
120 #endif // IMPELLER_ENABLE_VULKAN
121  }
122  FML_UNREACHABLE();
123 }

References impeller::PlaygroundImplVK::IsVulkanDriverPresent(), impeller::kMetal, impeller::kOpenGLES, and impeller::kVulkan.

Referenced by impeller::ComputePlaygroundTest::SetUp(), impeller::PlaygroundTest::SetUp(), and SetupContext().

◆ TeardownWindow()

void impeller::Playground::TeardownWindow ( )

Definition at line 151 of file playground.cc.

151  {
152  if (host_buffer_) {
153  host_buffer_.reset();
154  }
155  if (context_) {
156  context_->Shutdown();
157  }
158  context_.reset();
159  impl_.reset();
160 }

Referenced by impeller::ComputePlaygroundTest::TearDown(), and impeller::PlaygroundTest::TearDown().

◆ WillRenderSomething()

bool impeller::Playground::WillRenderSomething ( ) const

Returns true if OpenPlaygroundHere will actually render anything.

Definition at line 516 of file playground.cc.

516  {
518 }

References impeller::PlaygroundSwitches::enable_playground, and switches_.

Member Data Documentation

◆ switches_


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