#include <playground.h>

Inheritance diagram for impeller::Playground:

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.

std::shared_ptr< Context >	GetContext () const

std::shared_ptr< Context >	MakeContext () const

bool	OpenPlaygroundHere (const RenderCallback &render_callback)

bool	OpenPlaygroundHere (SinglePassCallback pass_callback)

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

std::shared_ptr< Texture >	CreateTextureCubeForFixture (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.

GLProcAddressResolver	CreateGLProcAddressResolver () const

VKProcAddressResolver	CreateVKProcAddressResolver () const

void	SetGPUDisabled (bool disabled) const
	Mark the GPU as unavilable.

Static Public Member Functions
static bool	ShouldOpenNewPlaygrounds ()

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

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

static std::shared_ptr< Texture >	CreateTextureForMapping (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.

                                                  : switches_(switches) {
  InitializeGLFWOnce();
  SetupSwiftshaderOnce(switches_.use_swiftshader);
}

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.

          {
  return impl_->CreateGLProcAddressResolver();
}

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.

                                                  {
  std::array<DecompressedImage, 6> images;
  for (size_t i = 0; i < fixture_names.size(); i++) {
    auto image = DecodeImageRGBA(
        LoadFixtureImageCompressed(OpenAssetAsMapping(fixture_names[i])));
    if (!image.has_value()) {
      return nullptr;
    }
    images[i] = image.value();
  }
 
  TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = StorageMode::kDevicePrivate;
  texture_descriptor.type = TextureType::kTextureCube;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = images[0].GetSize();
  texture_descriptor.mip_count = 1u;
 
  auto texture =
      context_->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!texture) {
    VALIDATION_LOG << "Could not allocate texture cube.";
    return nullptr;
  }
  texture->SetLabel("Texture cube");
 
  auto cmd_buffer = context_->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
  for (size_t i = 0; i < fixture_names.size(); i++) {
    auto device_buffer = context_->GetResourceAllocator()->CreateBufferWithCopy(
        *images[i].GetAllocation());
    blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer), texture, {},
                       "", /*mip_level=*/0, /*slice=*/i);
  }
 
  if (!blit_pass->EncodeCommands() ||
      !context_->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok()) {
    VALIDATION_LOG << "Could not upload texture to device memory.";
    return nullptr;
  }
 
  return texture;
}

References impeller::DeviceBuffer::AsBufferView(), DecodeImageRGBA(), impeller::TextureDescriptor::format, i, image, images, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kTextureCube, LoadFixtureImageCompressed(), impeller::TextureDescriptor::mip_count, OpenAssetAsMapping(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, 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.

                                  {
  auto texture = CreateTextureForMapping(
      context_, OpenAssetAsMapping(fixture_name), enable_mipmapping);
  if (texture == nullptr) {
    return nullptr;
  }
  texture->SetLabel(fixture_name);
  return texture;
}

References CreateTextureForMapping(), OpenAssetAsMapping(), and texture.

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

                            {
  auto image = Playground::DecodeImageRGBA(
      Playground::LoadFixtureImageCompressed(std::move(mapping)));
  if (!image.has_value()) {
    return nullptr;
  }
  return CreateTextureForDecompressedImage(context, image.value(),
                                           enable_mipmapping);
}

References impeller::CreateTextureForDecompressedImage(), DecodeImageRGBA(), image, 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.

          {
  return impl_->CreateVKProcAddressResolver();
}

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.

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

References image, and VALIDATION_LOG.

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

◆ GetContentScale()

Point impeller::Playground::GetContentScale ( ) const

Definition at line 189 of file playground.cc.

                                        {
  return impl_->GetContentScale();
}

Referenced by impeller::testing::CanRenderConicalGradientWithDithering(), impeller::testing::CanRenderSweepGradientWithDithering(), and impeller::testing::MaskBlurVariantTest().

◆ GetContext()

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

Definition at line 91 of file playground.cc.

                                                    {
  return context_;
}

Referenced by impeller::DlPlayground::CreateDlImageForFixture(), impeller::EntityPlayground::GetContentContext(), impeller::interop::testing::PlaygroundTest::GetInteropContext(), impeller::testing::RendererDartTest::GetIsolate(), impeller::testing::BlendFilterContentsTest::MakeTexture(), impeller::testing::GaussianBlurFilterContentsTest::MakeTexture(), impeller::testing::MatrixFilterContentsTest::MakeTexture(), impeller::AiksPlayground::OpenPlaygroundHere(), impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), OpenPlaygroundHere(), impeller::RuntimeStagePlayground::RegisterStage(), and impeller::testing::RendererDartTest::RenderDartToPlayground().

◆ GetCursorPosition()

Point impeller::Playground::GetCursorPosition ( ) const

Definition at line 181 of file playground.cc.

                                          {
  return cursor_position_;
}

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

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

References fml::TimePoint::Now().

◆ GetWindowSize()

ISize impeller::Playground::GetWindowSize ( ) const

Definition at line 185 of file playground.cc.

                                      {
  return window_size_;
}

Referenced by impeller::testing::RendererDartTest::GetRenderedTextureFromDart(), OpenPlaygroundHere(), and impeller::testing::RendererDartTest::RunDartFunctionWithWindowSize().

◆ GetWindowTitle()

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

pure virtual

Implemented in impeller::ComputePlaygroundTest, and impeller::PlaygroundTest.

Referenced by OpenPlaygroundHere().

◆ IsPlaygroundEnabled()

bool impeller::Playground::IsPlaygroundEnabled ( ) const

Definition at line 147 of file playground.cc.

                                           {
  return switches_.enable_playground;
}

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

Referenced by impeller::testing::RendererDartTest::RenderDartToPlayground().

◆ LoadFixtureImageCompressed()

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

static

Definition at line 361 of file playground.cc.

                                       {
  auto compressed_image = CompressedImageSkia::Create(std::move(mapping));
  if (!compressed_image) {
    VALIDATION_LOG << "Could not create compressed image.";
    return nullptr;
  }
 
  return compressed_image;
}

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.

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

◆ OpenAssetAsMapping()

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

pure virtual

Implemented in impeller::ComputePlaygroundTest, and impeller::PlaygroundTest.

Referenced by CreateTextureCubeForFixture(), and CreateTextureForFixture().

◆ OpenPlaygroundHere() [1/2]

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

Definition at line 201 of file playground.cc.

                                                     {
  if (!switches_.enable_playground) {
    return true;
  }
 
  if (!render_callback) {
    return true;
  }
 
  IMGUI_CHECKVERSION();
  ImGui::CreateContext();
  fml::ScopedCleanupClosure destroy_imgui_context(
      []() { ImGui::DestroyContext(); });
  ImGui::StyleColorsDark();
 
  auto& io = ImGui::GetIO();
  io.IniFilename = nullptr;
  io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
  io.ConfigWindowsResizeFromEdges = true;
 
  auto window = reinterpret_cast<GLFWwindow*>(impl_->GetWindowHandle());
  if (!window) {
    return false;
  }
  ::glfwSetWindowTitle(window, GetWindowTitle().c_str());
  ::glfwSetWindowUserPointer(window, this);
  ::glfwSetWindowSizeCallback(
      window, [](GLFWwindow* window, int width, int height) -> void {
        auto playground =
            reinterpret_cast<Playground*>(::glfwGetWindowUserPointer(window));
        if (!playground) {
          return;
        }
        playground->SetWindowSize(ISize{width, height}.Max({}));
      });
  ::glfwSetKeyCallback(window, &PlaygroundKeyCallback);
  ::glfwSetCursorPosCallback(window, [](GLFWwindow* window, double x,
                                        double y) {
    reinterpret_cast<Playground*>(::glfwGetWindowUserPointer(window))
        ->SetCursorPosition({static_cast<Scalar>(x), static_cast<Scalar>(y)});
  });
 
  ImGui_ImplGlfw_InitForOther(window, true);
  fml::ScopedCleanupClosure shutdown_imgui([]() { ImGui_ImplGlfw_Shutdown(); });
 
  ImGui_ImplImpeller_Init(context_);
  fml::ScopedCleanupClosure shutdown_imgui_impeller(
      []() { ImGui_ImplImpeller_Shutdown(); });
 
  ImGui::SetNextWindowPos({10, 10});
 
  ::glfwSetWindowSize(window, GetWindowSize().width, GetWindowSize().height);
  ::glfwSetWindowPos(window, 200, 100);
  ::glfwShowWindow(window);
 
  while (true) {
#if FML_OS_MACOSX
    fml::ScopedNSAutoreleasePool pool;
#endif
    ::glfwPollEvents();
 
    if (::glfwWindowShouldClose(window)) {
      return true;
    }
 
    ImGui_ImplGlfw_NewFrame();
 
    auto surface = impl_->AcquireSurfaceFrame(context_);
    RenderTarget render_target = surface->GetRenderTarget();
 
    ImGui::NewFrame();
    ImGui::DockSpaceOverViewport(ImGui::GetMainViewport(),
                                 ImGuiDockNodeFlags_PassthruCentralNode);
    bool result = render_callback(render_target);
    ImGui::Render();
 
    // Render ImGui overlay.
    {
      auto buffer = context_->CreateCommandBuffer();
      if (!buffer) {
        VALIDATION_LOG << "Could not create command buffer.";
        return false;
      }
      buffer->SetLabel("ImGui Command Buffer");
 
      auto color0 = render_target.GetColorAttachment(0);
      color0.load_action = LoadAction::kLoad;
      if (color0.resolve_texture) {
        color0.texture = color0.resolve_texture;
        color0.resolve_texture = nullptr;
        color0.store_action = StoreAction::kStore;
      }
      render_target.SetColorAttachment(color0, 0);
      render_target.SetStencilAttachment(std::nullopt);
      render_target.SetDepthAttachment(std::nullopt);
 
      auto pass = buffer->CreateRenderPass(render_target);
      if (!pass) {
        VALIDATION_LOG << "Could not create render pass.";
        return false;
      }
      pass->SetLabel("ImGui Render Pass");
      if (!host_buffer_) {
        host_buffer_ = HostBuffer::Create(
            context_->GetResourceAllocator(), context_->GetIdleWaiter(),
            context_->GetCapabilities()->GetMinimumUniformAlignment());
      }
 
      ImGui_ImplImpeller_RenderDrawData(ImGui::GetDrawData(), *pass,
                                        *host_buffer_);
 
      pass->EncodeCommands();
 
      if (!context_->GetCommandQueue()->Submit({buffer}).ok()) {
        return false;
      }
    }
 
    if (!result || !surface->Present()) {
      return false;
    }
 
    if (!ShouldKeepRendering()) {
      break;
    }
  }
 
  ::glfwHideWindow(window);
 
  return true;
}

References impeller::HostBuffer::Create(), impeller::PlaygroundSwitches::enable_playground, impeller::RenderTarget::GetColorAttachment(), GetWindowSize(), GetWindowTitle(), height, 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(), surface, switches_, VALIDATION_LOG, width, window, x, and y.

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

◆ OpenPlaygroundHere() [2/2]

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

Definition at line 334 of file playground.cc.

                                                                    {
  return OpenPlaygroundHere(
      [context = GetContext(), &pass_callback](RenderTarget& render_target) {
        auto buffer = context->CreateCommandBuffer();
        if (!buffer) {
          return false;
        }
        buffer->SetLabel("Playground Command Buffer");
 
        auto pass = buffer->CreateRenderPass(render_target);
        if (!pass) {
          return false;
        }
        pass->SetLabel("Playground Render Pass");
 
        if (!pass_callback(*pass)) {
          return false;
        }
 
        pass->EncodeCommands();
        if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
          return false;
        }
        return true;
      });
}

References GetContext(), and OpenPlaygroundHere().

◆ SetCapabilities()

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

Definition at line 511 of file playground.cc.

                                                     {
  return impl_->SetCapabilities(capabilities);
}

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

                                                {
  impl_->SetGPUDisabled(value);
}

References value.

◆ SetupContext()

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

Definition at line 125 of file playground.cc.

                                                                  {
  FML_CHECK(SupportsBackend(backend));
 
  impl_ = PlaygroundImpl::Create(backend, switches);
  if (!impl_) {
    FML_LOG(WARNING) << "PlaygroundImpl::Create failed.";
    return;
  }
 
  context_ = impl_->GetContext();
}

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

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

◆ SetupWindow()

void impeller::Playground::SetupWindow ( )

Definition at line 138 of file playground.cc.

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

References FML_LOG, fml::TimePoint::Now(), and fml::TimePoint::ToEpochDelta().

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.

                                         {
  window_size_ = size;
}

Referenced by OpenPlaygroundHere().

◆ ShouldKeepRendering()

bool impeller::Playground::ShouldKeepRendering ( ) const

protectedvirtual

Definition at line 507 of file playground.cc.

                                           {
  return true;
}

Referenced by OpenPlaygroundHere().

◆ ShouldOpenNewPlaygrounds()

bool impeller::Playground::ShouldOpenNewPlaygrounds ( )

static

Definition at line 164 of file playground.cc.

                                          {
  return gShouldOpenNewPlaygrounds;
}

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.

                                                          {
  switch (backend) {
    case PlaygroundBackend::kMetal:
#if IMPELLER_ENABLE_METAL
      return true;
#else   // IMPELLER_ENABLE_METAL
      return false;
#endif  // IMPELLER_ENABLE_METAL
    case PlaygroundBackend::kOpenGLES:
#if IMPELLER_ENABLE_OPENGLES
      return true;
#else   // IMPELLER_ENABLE_OPENGLES
      return false;
#endif  // IMPELLER_ENABLE_OPENGLES
    case PlaygroundBackend::kVulkan:
#if IMPELLER_ENABLE_VULKAN
      return PlaygroundImplVK::IsVulkanDriverPresent();
#else   // IMPELLER_ENABLE_VULKAN
      return false;
#endif  // IMPELLER_ENABLE_VULKAN
  }
  FML_UNREACHABLE();
}

References FML_UNREACHABLE, 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.

                                {
  if (host_buffer_) {
    host_buffer_.reset();
  }
  if (context_) {
    context_->Shutdown();
  }
  context_.reset();
  impl_.reset();
}

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.

                                           {
  return switches_.enable_playground;
}

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

Member Data Documentation

◆ switches_

const PlaygroundSwitches impeller::Playground::switches_

protected

Definition at line 131 of file playground.h.

Referenced by impeller::interop::testing::PlaygroundTest::CreateContext(), impeller::PlaygroundTest::GetWindowTitle(), IsPlaygroundEnabled(), OpenPlaygroundHere(), impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), Playground(), impeller::ComputePlaygroundTest::SetUp(), impeller::PlaygroundTest::SetUp(), and WillRenderSomething().

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

impeller/playground/playground.h
impeller/playground/playground.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ GLProcAddressResolver

◆ RenderCallback

◆ SinglePassCallback

◆ VKProcAddressResolver

Constructor & Destructor Documentation

◆ Playground()

◆ ~Playground()

Member Function Documentation

◆ CreateGLProcAddressResolver()

◆ CreateTextureCubeForFixture()

◆ CreateTextureForFixture()

◆ CreateTextureForMapping()

◆ CreateVKProcAddressResolver()

◆ DecodeImageRGBA()

◆ GetContentScale()

◆ GetContext()

◆ GetCursorPosition()

◆ GetSecondsElapsed()

◆ GetWindowSize()

◆ GetWindowTitle()

◆ IsPlaygroundEnabled()

◆ LoadFixtureImageCompressed()

◆ MakeContext()

◆ OpenAssetAsMapping()

◆ OpenPlaygroundHere() [1/2]

◆ OpenPlaygroundHere() [2/2]

◆ SetCapabilities()

◆ SetGPUDisabled()

◆ SetupContext()

◆ SetupWindow()

◆ SetWindowSize()

◆ ShouldKeepRendering()

◆ ShouldOpenNewPlaygrounds()

◆ SupportsBackend()

◆ TeardownWindow()

◆ WillRenderSomething()

Member Data Documentation

◆ switches_