impeller::Playground Class Reference

#include <playground.h>

Inheritance diagram for impeller::Playground:

Classes
struct	GLFWInitializer

Public Types
using	SinglePassCallback = std::function< bool(RenderPass &pass)>

Public Member Functions
	Playground (PlaygroundSwitches switches)
virtual	~Playground ()
void	SetupContext (PlaygroundBackend backend)
void	SetupWindow ()
void	TeardownWindow ()
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< Context >	GetContext () const
bool	OpenPlaygroundHere (const Renderer::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

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

Protected Attributes
const PlaygroundSwitches	switches_

Detailed Description

Definition at line 33 of file playground.h.

Member Typedef Documentation

SinglePassCallback

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

Definition at line 35 of file playground.h.

Constructor & Destructor Documentation

Playground()

impeller::Playground::Playground ( PlaygroundSwitches  switches )

explicit

Definition at line 80 of file playground.cc.

    : switches_(switches),
      glfw_initializer_(std::make_unique<GLFWInitializer>()) {}

~Playground()

impeller::Playground::~Playground ( )

virtualdefault

Member Function Documentation

CreateTextureCubeForFixture()

std::shared_ptr< Texture > impeller::Playground::CreateTextureCubeForFixture

(

std::array< const char *, 6 >

fixture_names

)

const

Definition at line 487 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();
  }
 
  auto texture_descriptor = TextureDescriptor{};
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.type = TextureType::kTextureCube;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = images[0].GetSize();
  texture_descriptor.mip_count = 1u;
 
  auto texture = renderer_->GetContext()->GetResourceAllocator()->CreateTexture(
      texture_descriptor);
  if (!texture) {
    VALIDATION_LOG << "Could not allocate texture cube.";
    return nullptr;
  }
  texture->SetLabel("Texture cube");
 
  for (size_t i = 0; i < fixture_names.size(); i++) {
    auto uploaded =
        texture->SetContents(images[i].GetAllocation()->GetMapping(),
                             images[i].GetAllocation()->GetSize(), i);
    if (!uploaded) {
      VALIDATION_LOG << "Could not upload texture to device memory.";
      return nullptr;
    }
  }
 
  return texture;
}

References DecodeImageRGBA(), impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::kTextureCube, LoadFixtureImageCompressed(), OpenAssetAsMapping(), impeller::TextureDescriptor::storage_mode, and VALIDATION_LOG.

CreateTextureForFixture()

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

Definition at line 474 of file playground.cc.

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

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 461 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(), and LoadFixtureImageCompressed().

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

DecodeImageRGBA()

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

static

Definition at line 365 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 VALIDATION_LOG.

Referenced by CreateTextureCubeForFixture(), and CreateTextureForMapping().

GetContentScale()

Point impeller::Playground::GetContentScale

(

)

const

Definition at line 177 of file playground.cc.

                                        {
  return impl_->GetContentScale();
}

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

GetContext()

std::shared_ptr< Context > impeller::Playground::GetContext

(

)

const

Definition at line 86 of file playground.cc.

                                                    {
  return context_;
}

Referenced by impeller::testing::RendererDartTest::GetIsolate(), impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::AiksPlayground::OpenPlaygroundHere(), OpenPlaygroundHere(), and impeller::RuntimeStagePlayground::RegisterStage().

GetCursorPosition()

Point impeller::Playground::GetCursorPosition

(

)

const

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

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

GetWindowSize()

ISize impeller::Playground::GetWindowSize

(

)

const

Definition at line 173 of file playground.cc.

                                      {
  return window_size_;
}

Referenced by OpenPlaygroundHere().

GetWindowTitle()

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

pure virtual

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

Referenced by OpenPlaygroundHere().

LoadFixtureImageCompressed()

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

static

Definition at line 354 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(), and CreateTextureForMapping().

OpenAssetAsMapping()

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

pure virtual

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

Referenced by CreateTextureCubeForFixture(), and CreateTextureForFixture().

OpenPlaygroundHere() [1/2]

bool impeller::Playground::OpenPlaygroundHere

(

const Renderer::RenderCallback &

render_callback

)

Definition at line 189 of file playground.cc.

                                                   {
  if (!switches_.enable_playground) {
    return true;
  }
 
  if (!render_callback) {
    return true;
  }
 
  if (!renderer_ || !renderer_->IsValid()) {
    return false;
  }
 
  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(renderer_->GetContext());
  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();
 
    Renderer::RenderCallback wrapped_callback =
        [render_callback,
         &renderer = renderer_](RenderTarget& render_target) -> bool {
      ImGui::NewFrame();
      ImGui::DockSpaceOverViewport(ImGui::GetMainViewport(),
                                   ImGuiDockNodeFlags_PassthruCentralNode);
      bool result = render_callback(render_target);
      ImGui::Render();
 
      // Render ImGui overlay.
      {
        auto buffer = renderer->GetContext()->CreateCommandBuffer();
        if (!buffer) {
          return false;
        }
        buffer->SetLabel("ImGui Command Buffer");
 
        if (render_target.GetColorAttachments().empty()) {
          return false;
        }
 
        auto color0 = render_target.GetColorAttachments().find(0)->second;
        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) {
          return false;
        }
        pass->SetLabel("ImGui Render Pass");
 
        ImGui_ImplImpeller_RenderDrawData(ImGui::GetDrawData(), *pass);
 
        pass->EncodeCommands();
        if (!buffer->SubmitCommands()) {
          return false;
        }
      }
 
      return result;
    };
 
    if (!renderer_->Render(impl_->AcquireSurfaceFrame(renderer_->GetContext()),
                           wrapped_callback)) {
      VALIDATION_LOG << "Could not render into the surface.";
      return false;
    }
 
    if (!ShouldKeepRendering()) {
      break;
    }
  }
 
  ::glfwHideWindow(window);
 
  return true;
}

References impeller::PlaygroundSwitches::enable_playground, GetWindowSize(), GetWindowTitle(), ImGui_ImplImpeller_Init(), ImGui_ImplImpeller_RenderDrawData(), ImGui_ImplImpeller_Shutdown(), impeller::kLoad, impeller::kStore, impeller::TSize< T >::Max(), impeller::PlaygroundKeyCallback(), ShouldKeepRendering(), switches_, and VALIDATION_LOG.

Referenced by impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::AiksPlayground::OpenPlaygroundHere(), and OpenPlaygroundHere().

OpenPlaygroundHere() [2/2]

bool impeller::Playground::OpenPlaygroundHere

(

SinglePassCallback

pass_callback

)

Definition at line 327 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 (!buffer->SubmitCommands()) {
          return false;
        }
        return true;
      });
}

References GetContext(), and OpenPlaygroundHere().

SetupContext()

void impeller::Playground::SetupContext

(

PlaygroundBackend

backend

)

Definition at line 114 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(), SupportsBackend(), and switches_.

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

SetupWindow()

void impeller::Playground::SetupWindow

(

)

Definition at line 126 of file playground.cc.

                             {
  if (!context_) {
    FML_LOG(WARNING) << "Asked to set up a window with no context (call "
                        "SetupContext first).";
    return;
  }
  auto renderer = std::make_unique<Renderer>(context_);
  if (!renderer->IsValid()) {
    return;
  }
  renderer_ = std::move(renderer);
 
  start_time_ = fml::TimePoint::Now().ToEpochDelta();
}

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

ShouldKeepRendering()

bool impeller::Playground::ShouldKeepRendering ( ) const

protectedvirtual

Definition at line 531 of file playground.cc.

                                           {
  return true;
}

Referenced by OpenPlaygroundHere().

ShouldOpenNewPlaygrounds()

bool impeller::Playground::ShouldOpenNewPlaygrounds ( )

static

Definition at line 152 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 90 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 true;
#else   // IMPELLER_ENABLE_VULKAN
      return false;
#endif  // IMPELLER_ENABLE_VULKAN
  }
  FML_UNREACHABLE();
}

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

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

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

Member Data Documentation

switches_

const PlaygroundSwitches impeller::Playground::switches_

protected

Definition at line 91 of file playground.h.

Referenced by impeller::DlPlayground::OpenPlaygroundHere(), impeller::EntityPlayground::OpenPlaygroundHere(), impeller::AiksPlayground::OpenPlaygroundHere(), OpenPlaygroundHere(), and SetupContext().

---

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

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