impeller::Playground Class Reference

#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	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.
RuntimeStageBackend	GetRuntimeStageBackend () const

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
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.
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.
virtual void	EnsureContextSupportsAntialiasLines ()
	Make sure that when the context is later created that it will support the experimental AA lines flag.
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)

Detailed Description

Definition at line 37 of file playground.h.

Member Typedef Documentation

GLProcAddressResolver

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

Definition at line 107 of file playground.h.

RenderCallback

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

Definition at line 70 of file playground.h.

SinglePassCallback

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

Definition at line 39 of file playground.h.

VKProcAddressResolver

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

Definition at line 110 of file playground.h.

Constructor & Destructor Documentation

Playground()

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

explicit

Definition at line 90 of file playground.cc.

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

References impeller::InitializeGLFWOnce(), 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 610 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 547 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 535 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 522 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 615 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 461 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 99 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.

EnsureContextSupportsAntialiasLines()

void impeller::Playground::EnsureContextSupportsAntialiasLines ( )

protectedvirtual

Make sure that when the context is later created that it will support the experimental AA lines flag.

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

Definition at line 121 of file playground.cc.

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

References impeller::Flags::antialiased_lines, impeller::PlaygroundSwitches::flags, 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 112 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 146 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 275 of file playground.cc.

                                        {
  return GetImpl()->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 126 of file playground.cc.

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

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

GetCursorPosition()

Point impeller::Playground::GetCursorPosition

(

)

const

Definition at line 263 of file playground.cc.

                                          {
  return cursor_position_;
}

GetRuntimeStageBackend()

RuntimeStageBackend impeller::Playground::GetRuntimeStageBackend

(

)

const

Definition at line 624 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 279 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 167 of file playground.h.

{ 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 155 of file playground.cc.

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

References impeller::TypographerContextSkia::Make().

Referenced by GetContentContext().

GetWindowBounds()

IRect impeller::Playground::GetWindowBounds

(

)

const

Definition at line 271 of file playground.cc.

                                        {
  return IRect::MakeSize(window_size_);
}

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

GetWindowSize()

ISize impeller::Playground::GetWindowSize

(

)

const

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

                                           {
  return switches_.enable_playground;
}

References impeller::PlaygroundSwitches::enable_playground.

Referenced by impeller::DlPlayground::OpenPlaygroundHere(), 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 450 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 133 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.

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

                                                     {
  std::shared_ptr<Context> context = GetContext();
  FML_CHECK(context);
 
  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*>(GetImpl()->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 = 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(), 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::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 423 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 104 of file playground.cc.

                                                      {
#if __arm64__ && FML_OS_MACOSX
  return backend_ == PlaygroundBackend::kMetal;
#else
  return false;
#endif
}

References impeller::kMetal.

Referenced by EnsureContextSupportsWideGamut().

SetCapabilities()

fml::Status impeller::Playground::SetCapabilities

(

const std::shared_ptr< Capabilities > &

capabilities

)

Definition at line 601 of file playground.cc.

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

SetGPUDisabled()

void impeller::Playground::SetGPUDisabled

(

bool

disabled

)

const

Mark the GPU as unavilable.

Only supported on the Metal backend.

Definition at line 620 of file playground.cc.

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

References value.

SetTypographerContext()

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

protected

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

                                         {
  window_size_ = size;
}

Referenced by OpenPlaygroundHere().

ShouldKeepRendering()

bool impeller::Playground::ShouldKeepRendering ( ) const

protectedvirtual

Definition at line 597 of file playground.cc.

                                           {
  return true;
}

Referenced by OpenPlaygroundHere().

ShouldOpenNewPlaygrounds()

bool impeller::Playground::ShouldOpenNewPlaygrounds ( )

static

Definition at line 246 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 169 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 228 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().

WillRenderSomething()

bool impeller::Playground::WillRenderSomething

(

)

const

Returns true if OpenPlaygroundHere will actually render anything.

Definition at line 606 of file playground.cc.

                                           {
  return switches_.enable_playground;
}

References impeller::PlaygroundSwitches::enable_playground.

---

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

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