#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 (PlaygroundBackend backend, const PlaygroundSwitches &switches)

virtual	~Playground ()

bool	IsPlaygroundEnabled () const

Point	GetCursorPosition () const

ISize	GetWindowSize () const

IRect	GetWindowBounds () 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

ContentContext &	GetContentContext () const

std::shared_ptr< TypographerContext >	GetTypographerContext () const

bool	ShouldWriteGoldenImage ()
	Whether this instance will write a golden image of the output from \|OpenPlaygroundHere\|.

void	SetEnableWriteGolden (bool write_golden)
	Sets a particular test to either write a golden or not, false by default.

bool	OpenPlaygroundHere (const RenderCallback &render_callback)

bool	OpenPlaygroundHere (const 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)

GLProcAddressResolver	CreateGLProcAddressResolver () const

VKProcAddressResolver	CreateVKProcAddressResolver () const

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

RuntimeStageBackend	GetRuntimeStageBackend () const

bool	InitializePipelineDescriptorForRendering (PipelineDescriptor &desc) const
	Initializes the provided \|PipelineDescriptor\| with appropriate default values to match the conditions under which a pipeline will be rendered.

Static Public Member Functions
static void	OnTearDownTestEnvironment ()

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
void	TearDownContextData ()

virtual bool	ShouldKeepRendering () const

virtual void	EnsureContextIsUnique ()
	Make sure that when the context is later created that it will not be shared with any other playgrounds.

bool	PlatformSupportsWideGamutTests () const
	Returns true if the platform can support wide gamuts.

bool	RenderingSupportsMSAA () const
	Returns true if the rendering path supports MSAA rendering.

SampleCount	GetDefaultSampleCount () const
	Returns the default sample count of the rendering path.

virtual bool	EnsureContextSupportsWideGamut ()
	Make sure that when the context is later created that it will support wide gamuts if the platform supports it. Returns whether the platform supports wide gamut.

const PlaygroundSwitches &	GetSwitches () const
	Return an unmodifiable reference to the current switches. The switches might change at the start of a test as it has a brief opportunity to call any of the Ensure* methods that define the environment it expects, but should be stable by the time any subsequent methods that might perform work are called.

void	SetTypographerContext (std::shared_ptr< TypographerContext > typographer_context)

void	SetWindowSize (ISize size)

virtual testing::GoldenDigestManager *	GetGoldenDigestManager () const

Detailed Description

Definition at line 42 of file playground.h.

Member Typedef Documentation

◆ GLProcAddressResolver

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

Definition at line 119 of file playground.h.

◆ RenderCallback

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

Definition at line 77 of file playground.h.

◆ SinglePassCallback

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

Definition at line 44 of file playground.h.

◆ VKProcAddressResolver

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

Definition at line 122 of file playground.h.

Constructor & Destructor Documentation

◆ Playground()

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

explicit

Definition at line 125 of file playground.cc.

    : backend_(backend), switches_(switches) {
  InitializeGLFWOnce();
  flutter::testing::SetupSwiftshaderOnce(switches_.use_swiftshader);
}

References flutter::testing::SetupSwiftshaderOnce(), and impeller::PlaygroundSwitches::use_swiftshader.

◆ ~Playground()

impeller::Playground::~Playground ( )

virtualdefault

Member Function Documentation

◆ CreateGLProcAddressResolver()

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

Definition at line 775 of file playground.cc.

          {
  return GetImpl()->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 716 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 =
      GetContext()->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!texture) {
    VALIDATION_LOG << "Could not allocate texture cube.";
    return nullptr;
  }
  texture->SetLabel("Texture cube");
 
  auto cmd_buffer = GetContext()->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
  for (size_t i = 0; i < fixture_names.size(); i++) {
    auto device_buffer =
        GetContext()->GetResourceAllocator()->CreateBufferWithCopy(
            *images[i].GetAllocation());
    blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer), texture, {},
                       "", /*mip_level=*/0, /*slice=*/i);
  }
 
  if (!blit_pass->EncodeCommands() ||
      !GetContext()->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, GetContext(), 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 704 of file playground.cc.

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

References CreateTextureForMapping(), GetContext(), 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 691 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 context, 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 780 of file playground.cc.

          {
  return GetImpl()->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 630 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().

◆ EnsureContextIsUnique()

void impeller::Playground::EnsureContextIsUnique ( )

protectedvirtual

Make sure that when the context is later created that it will not be shared with any other playgrounds.

Must be called before any other method except for the Ensure family of methods.

Definition at line 134 of file playground.cc.

                                       {
  FML_CHECK(!context_) << "Must be called before a context is created.";
  switches_.can_share_context = false;
}

References impeller::PlaygroundSwitches::can_share_context, and FML_CHECK.

◆ EnsureContextSupportsWideGamut()

bool impeller::Playground::EnsureContextSupportsWideGamut ( )

protectedvirtual

Make sure that when the context is later created that it will support wide gamuts if the platform supports it. Returns whether the platform supports wide gamut.

Must be called before any other method except for the Ensure family of methods.

Callers should abort (such as via GTEST_SKIP) if the method returns false if their behavior depends on the wide gamut support.

See also: PlatformSupportsWideGamut()

Definition at line 190 of file playground.cc.

                                                {
  FML_CHECK(!context_) << "Must be called before a context is created.";
  if (!PlatformSupportsWideGamutTests()) {
    return false;
  }
  switches_.enable_wide_gamut = true;
  return true;
}

References impeller::PlaygroundSwitches::enable_wide_gamut, FML_CHECK, and PlatformSupportsWideGamutTests().

◆ GetContentContext()

ContentContext & impeller::Playground::GetContentContext ( ) const

Definition at line 219 of file playground.cc.

                                                    {
  if (!content_context_) {
    content_context_ =
        std::make_unique<ContentContext>(GetContext(), GetTypographerContext());
    FML_CHECK(content_context_) << "Failed to create ContentContext";
  }
  return *content_context_;
}

References FML_CHECK, GetContext(), and GetTypographerContext().

Referenced by impeller::testing::BlendFilterContentsTest::MakeTexture(), impeller::testing::GaussianBlurFilterContentsTest::MakeTexture(), impeller::testing::MatrixFilterContentsTest::MakeTexture(), impeller::testing::MorphologyFilterContentsTest::MakeTexture(), impeller::EntityPlayground::OpenPlaygroundHere(), and impeller::EntityPlayground::OpenPlaygroundHere().

◆ GetContentScale()

Point impeller::Playground::GetContentScale ( ) const

Definition at line 348 of file playground.cc.

                                        {
  return GetImpl()->GetContentScale();
}

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

◆ GetContext()

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

Definition at line 199 of file playground.cc.

                                                    {
  if (!context_) {
    SetupContext();
  }
  return context_;
}

◆ GetCursorPosition()

Point impeller::Playground::GetCursorPosition ( ) const

Definition at line 336 of file playground.cc.

                                          {
  return cursor_position_;
}

◆ GetDefaultSampleCount()

SampleCount impeller::Playground::GetDefaultSampleCount ( ) const

protected

Returns the default sample count of the rendering path.

Definition at line 175 of file playground.cc.

                                                    {
  return RenderingSupportsMSAA() ? SampleCount::kCount4 : SampleCount::kCount1;
}

References impeller::kCount1, impeller::kCount4, and RenderingSupportsMSAA().

Referenced by InitializePipelineDescriptorForRendering().

◆ GetGoldenDigestManager()

testing::GoldenDigestManager * impeller::Playground::GetGoldenDigestManager ( ) const

protectedvirtual

Reimplemented in impeller::PlaygroundTest.

Definition at line 121 of file playground.cc.

                                                                     {
  return nullptr;
}

Referenced by OpenPlaygroundHere().

◆ GetRuntimeStageBackend()

RuntimeStageBackend impeller::Playground::GetRuntimeStageBackend ( ) const

Definition at line 789 of file playground.cc.

                                                             {
  return GetImpl()->GetRuntimeStageBackend();
}

◆ GetSecondsElapsed()

Scalar impeller::Playground::GetSecondsElapsed ( ) const

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

Definition at line 352 of file playground.cc.

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

References fml::TimePoint::Now().

◆ GetSwitches()

const PlaygroundSwitches & impeller::Playground::GetSwitches ( ) const

inlineprotected

Return an unmodifiable reference to the current switches. The switches might change at the start of a test as it has a brief opportunity to call any of the Ensure* methods that define the environment it expects, but should be stable by the time any subsequent methods that might perform work are called.

Definition at line 183 of file playground.h.

183{ return switches_; }

Referenced by impeller::interop::testing::PlaygroundTest::CreateContext(), and impeller::PlaygroundTest::GetWindowTitle().

◆ GetTypographerContext()

std::shared_ptr< TypographerContext > impeller::Playground::GetTypographerContext ( ) const

Definition at line 228 of file playground.cc.

                                                                          {
  if (!typographer_context_) {
    typographer_context_ = TypographerContextSkia::Make();
  }
  return typographer_context_;
}

References impeller::TypographerContextSkia::Make().

Referenced by GetContentContext(), and impeller::DlPlayground::MakeScreenshot().

◆ GetWindowBounds()

IRect impeller::Playground::GetWindowBounds ( ) const

Definition at line 344 of file playground.cc.

                                        {
  return IRect::MakeSize(window_size_);
}

References impeller::TRect< T >::MakeSize().

◆ GetWindowSize()

ISize impeller::Playground::GetWindowSize ( ) const

Definition at line 340 of file playground.cc.

                                      {
  return window_size_;
}

Referenced by impeller::testing::RendererDartTest::GetRenderedTextureFromDart(), impeller::DlPlayground::MakeScreenshot(), 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().

◆ InitializePipelineDescriptorForRendering()

bool impeller::Playground::InitializePipelineDescriptorForRendering ( PipelineDescriptor & desc ) const

Initializes the provided |PipelineDescriptor| with appropriate default values to match the conditions under which a pipeline will be rendered.

Definition at line 179 of file playground.cc.

                                    {
  // Match the golden/verirication harness render target:
  // - msaa or single samples depending on the Context
  // - no depth or stencil
  desc.SetSampleCount(GetDefaultSampleCount());
  desc.ClearStencilAttachments();
  desc.ClearDepthAttachment();
  return true;
}

References impeller::PipelineDescriptor::ClearDepthAttachment(), impeller::PipelineDescriptor::ClearStencilAttachments(), GetDefaultSampleCount(), and impeller::PipelineDescriptor::SetSampleCount().

Referenced by impeller::testing::CreateDefaultPipeline(), impeller::testing::DrawCompressedTextureGolden(), and impeller::testing::DrawManuallyMippedTextureGolden().

◆ IsPlaygroundEnabled()

bool impeller::Playground::IsPlaygroundEnabled ( ) const

Definition at line 297 of file playground.cc.

                                           {
  return switches_.enable_playground;
}

References impeller::PlaygroundSwitches::enable_playground.

Referenced by impeller::testing::BlendModeTest(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), and impeller::testing::RendererDartTest::RenderDartToPlayground().

◆ LoadFixtureImageCompressed()

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

static

Definition at line 619 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 206 of file playground.cc.

                                                     {
  // This method is used to get a unique context that is not shared with
  // other playground tests. It requires that the test has called the
  // |EnsureContextIsUnique| method before it calls this method. We
  // verify those conditions here and then set up the context.
  FML_CHECK(!context_) << "MakeContext can only be called once";
  FML_CHECK(!switches_.can_share_context)
      << "MakeContext should only be called after EnsureContextIsUnique()";
  SetupContext();
 
  return context_;
}

References impeller::PlaygroundSwitches::can_share_context, and FML_CHECK.

◆ OnTearDownTestEnvironment()

void impeller::Playground::OnTearDownTestEnvironment ( )

static

Definition at line 115 of file playground.cc.

                                           {
  if (glfw_initialized_) {
    ::glfwTerminate();
  }
}

◆ 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 445 of file playground.cc.

                                                     {
  std::shared_ptr<Context> context = GetContext();
  FML_CHECK(context);
 
  if (!render_callback) {
    return true;
  }
 
  auto window = reinterpret_cast<GLFWwindow*>(impl_->GetWindowHandle());
  if (!window) {
    return false;
  }
  ::glfwSetWindowSize(window, GetWindowSize().width, GetWindowSize().height);
 
  bool writing_golden = GetGoldenDigestManager() && should_write_golden_;
  if (!switches_.enable_playground || writing_golden) {
    bool success = RenderImage(render_callback, false);
    if (success && writing_golden) {
      // Render twice for a golden result so the second pass observes warmed
      // pipeline and resource caches.
      success = RenderImage(render_callback, true);
    }
    if (!success || !switches_.enable_playground) {
      return success;
    }
  }
  FML_CHECK(switches_.enable_playground);
 
  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;
 
  ::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});
 
  ::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 = GetImpl()->AcquireSurfaceFrame(context);
    RenderTarget render_target = surface->GetRenderTarget();
 
    ImGui::NewFrame();
    ImGui::DockSpaceOverViewport(0, 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 context, impeller::HostBuffer::Create(), impeller::PlaygroundSwitches::enable_playground, FML_CHECK, impeller::RenderTarget::GetColorAttachment(), GetContext(), GetGoldenDigestManager(), 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, VALIDATION_LOG, width, window, x, and y.

Referenced by impeller::testing::DrawCompressedTextureGolden(), impeller::testing::DrawManuallyMippedTextureGolden(), impeller::AiksPlayground::OpenPlaygroundHere(), OpenPlaygroundHere(), impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::interop::testing::PlaygroundTest::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 ( const SinglePassCallback & pass_callback )

Definition at line 592 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 context, GetContext(), and OpenPlaygroundHere().

◆ PlatformSupportsWideGamutTests()

bool impeller::Playground::PlatformSupportsWideGamutTests ( ) const

protected

Returns true if the platform can support wide gamuts.

Definition at line 139 of file playground.cc.

                                                      {
#if __arm64__ && FML_OS_MACOSX
  switch (backend_) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      return true;
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
    case PlaygroundBackend::kVulkan:
      return false;
  }
#else
  return false;
#endif
}

References impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, and impeller::kVulkan.

Referenced by EnsureContextSupportsWideGamut().

◆ RenderingSupportsMSAA()

bool impeller::Playground::RenderingSupportsMSAA ( ) const

protected

Returns true if the rendering path supports MSAA rendering.

Definition at line 155 of file playground.cc.

                                             {
  // We could call GetContext(), but we don't want to cause it to be
  // created just yet. So, we make some assumptions here. If they are
  // insufficient then we should beef them up rather than just calling
  // GetContext() if we can.
  // Also, technically, we should check if it supports OffscreenMSAA
  // which might be a subset of supporting MSAA on screen, but for now
  // they seem to be closely related.
  switch (backend_) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      return true;
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
      return false;
    case PlaygroundBackend::kVulkan:
      return true;
  }
}

References impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, and impeller::kVulkan.

Referenced by GetDefaultSampleCount().

◆ SetCapabilities()

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

Definition at line 770 of file playground.cc.

                                                     {
  return GetImpl()->SetCapabilities(capabilities);
}

◆ SetEnableWriteGolden()

void impeller::Playground::SetEnableWriteGolden ( bool write_golden )

Sets a particular test to either write a golden or not, false by default.

Definition at line 364 of file playground.cc.

                                                       {
  should_write_golden_ = write_golden;
}

Referenced by impeller::PlaygroundTest::SetUp().

◆ SetGPUDisabled()

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

Mark the GPU as unavilable.

Only supported on the Metal backend.

Definition at line 785 of file playground.cc.

                                                {
  GetImpl()->SetGPUDisabled(value);
}

References value.

◆ SetTypographerContext()

void impeller::Playground::SetTypographerContext ( std::shared_ptr< TypographerContext > typographer_context )

protected

Definition at line 235 of file playground.cc.

                                                           {
  FML_CHECK(!typographer_context_)
      << "SetTypographerContext called after it has already been initialized";
  typographer_context_ = std::move(typographer_context);
}

References FML_CHECK.

◆ SetWindowSize()

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

protected

Definition at line 762 of file playground.cc.

                                         {
  window_size_ = size;
}

Referenced by OpenPlaygroundHere().

◆ ShouldKeepRendering()

bool impeller::Playground::ShouldKeepRendering ( ) const

protectedvirtual

Definition at line 766 of file playground.cc.

                                           {
  return true;
}

Referenced by OpenPlaygroundHere().

◆ ShouldOpenNewPlaygrounds()

bool impeller::Playground::ShouldOpenNewPlaygrounds ( )

static

Definition at line 319 of file playground.cc.

                                          {
  return gShouldOpenNewPlaygrounds;
}

References impeller::gShouldOpenNewPlaygrounds.

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

◆ ShouldWriteGoldenImage()

bool impeller::Playground::ShouldWriteGoldenImage ( )

Whether this instance will write a golden image of the output from |OpenPlaygroundHere|.

Definition at line 360 of file playground.cc.

                                        {
  return should_write_golden_;
}

◆ SupportsBackend()

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

static

Definition at line 242 of file playground.cc.

                                                          {
  switch (backend) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
#if IMPELLER_ENABLE_METAL
      return true;
#else   // IMPELLER_ENABLE_METAL
      return false;
#endif  // IMPELLER_ENABLE_METAL
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
#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::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, and impeller::kVulkan.

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

◆ TearDownContextData()

void impeller::Playground::TearDownContextData ( )

protected

Definition at line 301 of file playground.cc.

                                     {
  if (content_context_) {
    FML_CHECK(context_);
    [[maybe_unused]] auto result = context_->FlushCommandBuffers();
    content_context_.reset();
  }
  if (host_buffer_) {
    host_buffer_.reset();
  }
  if (context_) {
    context_->Shutdown();
  }
  context_.reset();
  impl_.reset();
}

References FML_CHECK.

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

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

Detailed Description

Member Typedef Documentation

◆ GLProcAddressResolver

◆ RenderCallback

◆ SinglePassCallback

◆ VKProcAddressResolver

Constructor & Destructor Documentation

◆ Playground()

◆ ~Playground()

Member Function Documentation

◆ CreateGLProcAddressResolver()

◆ CreateTextureCubeForFixture()

◆ CreateTextureForFixture()

◆ CreateTextureForMapping()

◆ CreateVKProcAddressResolver()

◆ DecodeImageRGBA()

◆ EnsureContextIsUnique()

◆ EnsureContextSupportsWideGamut()

◆ GetContentContext()

◆ GetContentScale()

◆ GetContext()

◆ GetCursorPosition()

◆ GetDefaultSampleCount()

◆ GetGoldenDigestManager()

◆ GetRuntimeStageBackend()

◆ GetSecondsElapsed()

◆ GetSwitches()

◆ GetTypographerContext()

◆ GetWindowBounds()

◆ GetWindowSize()

◆ GetWindowTitle()

◆ InitializePipelineDescriptorForRendering()

◆ IsPlaygroundEnabled()

◆ LoadFixtureImageCompressed()

◆ MakeContext()

◆ OnTearDownTestEnvironment()

◆ OpenAssetAsMapping()

◆ OpenPlaygroundHere() [1/2]

◆ OpenPlaygroundHere() [2/2]

◆ PlatformSupportsWideGamutTests()

◆ RenderingSupportsMSAA()

◆ SetCapabilities()

◆ SetEnableWriteGolden()

◆ SetGPUDisabled()

◆ SetTypographerContext()

◆ SetWindowSize()

◆ ShouldKeepRendering()

◆ ShouldOpenNewPlaygrounds()

◆ ShouldWriteGoldenImage()

◆ SupportsBackend()

◆ TearDownContextData()