#include <playground_test.h>

Inheritance diagram for impeller::interop::testing::PlaygroundTest:

Public Types
using	InteropPlaygroundCallback = std::function< bool(const ScopedObject< Context > &context, const ScopedObject< Surface > &surface)>

Public Types inherited from impeller::Playground
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
	PlaygroundTest ()

	~PlaygroundTest () override

	PlaygroundTest (const PlaygroundTest &)=delete

PlaygroundTest &	operator= (const PlaygroundTest &)=delete

void	SetUp () override

void	TearDown () override

ScopedObject< Context >	CreateContext () const

ScopedObject< Context >	GetInteropContext ()

hpp::Context	GetHPPContext ()

hpp::Texture	OpenAssetAsHPPTexture (std::string asset_name)

bool	OpenPlaygroundHere (InteropPlaygroundCallback callback)

std::unique_ptr< hpp::Mapping >	OpenAssetAsHPPMapping (std::string asset_name) const

Public Member Functions inherited from impeller::PlaygroundTest
	PlaygroundTest ()

void	SetUp () override

void	TearDown () override

PlaygroundBackend	GetBackend () const

std::unique_ptr< fml::Mapping >	OpenAssetAsMapping (std::string asset_name) const override

absl::StatusOr< RuntimeStage::Map >	OpenAssetAsRuntimeStage (const char *asset_name) const

std::string	GetWindowTitle () const override

Public Member Functions inherited from impeller::Playground
	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

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

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

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

Additional Inherited Members
Static Public Member Functions inherited from impeller::Playground
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 inherited from impeller::Playground
void	SetWindowSize (ISize size)

Protected Attributes inherited from impeller::Playground
const PlaygroundSwitches	switches_

Detailed Description

Definition at line 17 of file playground_test.h.

Member Typedef Documentation

◆ InteropPlaygroundCallback

using impeller::interop::testing::PlaygroundTest::InteropPlaygroundCallback = std::function<bool(const ScopedObject<Context>& context, const ScopedObject<Surface>& surface)>

Definition at line 42 of file playground_test.h.

Constructor & Destructor Documentation

◆ PlaygroundTest() [1/2]

impeller::interop::testing::PlaygroundTest::PlaygroundTest ( )

Definition at line 43 of file playground_test.cc.

                               {
  SetupImpellerHPPProcTableOnce();
}

References impeller::interop::testing::SetupImpellerHPPProcTableOnce().

◆ ~PlaygroundTest()

impeller::interop::testing::PlaygroundTest::~PlaygroundTest ( )

overridevirtualdefault

Reimplemented from impeller::PlaygroundTest.

◆ PlaygroundTest() [2/2]

impeller::interop::testing::PlaygroundTest::PlaygroundTest ( const PlaygroundTest & )

delete

Member Function Documentation

◆ CreateContext()

ScopedObject< Context > impeller::interop::testing::PlaygroundTest::CreateContext ( ) const

Definition at line 59 of file playground_test.cc.

                                                          {
  switch (GetBackend()) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      return Adopt<Context>(
          ImpellerContextCreateMetalNew(ImpellerGetVersion()));
    case PlaygroundBackend::kOpenGLES: {
      Playground::GLProcAddressResolver playground_gl_proc_address_callback =
          CreateGLProcAddressResolver();
      ImpellerProcAddressCallback gl_proc_address_callback =
          [](const char* proc_name, void* user_data) -> void* {
        return (*reinterpret_cast<Playground::GLProcAddressResolver*>(
            user_data))(proc_name);
      };
      return Adopt<Context>(ImpellerContextCreateOpenGLESNew(
          ImpellerGetVersion(), gl_proc_address_callback,
          &playground_gl_proc_address_callback));
    }
    case PlaygroundBackend::kVulkan:
      ImpellerContextVulkanSettings settings = {};
      struct UserData {
        Playground::VKProcAddressResolver resolver;
      } user_data;
      user_data.resolver = CreateVKProcAddressResolver();
      settings.user_data = &user_data;
      settings.enable_vulkan_validation = switches_.enable_vulkan_validation;
      settings.proc_address_callback = [](void* instance,         //
                                          const char* proc_name,  //
                                          void* user_data         //
                                          ) -> void* {
        auto resolver = reinterpret_cast<UserData*>(user_data)->resolver;
        if (resolver) {
          return resolver(instance, proc_name);
        } else {
          return nullptr;
        }
      };
      return Adopt<Context>(
          ImpellerContextCreateVulkanNew(ImpellerGetVersion(), &settings));
  }
  FML_UNREACHABLE();
}

References impeller::Playground::CreateGLProcAddressResolver(), impeller::Playground::CreateVKProcAddressResolver(), impeller::PlaygroundSwitches::enable_vulkan_validation, ImpellerContextVulkanSettings::enable_vulkan_validation, FML_UNREACHABLE, impeller::PlaygroundTest::GetBackend(), impeller::interop::ImpellerContextCreateMetalNew(), impeller::interop::ImpellerContextCreateOpenGLESNew(), impeller::interop::ImpellerContextCreateVulkanNew(), impeller::interop::ImpellerGetVersion(), instance, impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kVulkan, ImpellerContextVulkanSettings::proc_address_callback, impeller::Playground::switches_, ImpellerContextVulkanSettings::user_data, and user_data.

◆ GetHPPContext()

hpp::Context impeller::interop::testing::PlaygroundTest::GetHPPContext ( )

Definition at line 184 of file playground_test.cc.

                                         {
  auto c_context = GetInteropContext().GetC();
  ImpellerContextRetain(c_context);
  return hpp::Context{c_context, hpp::AdoptTag::kAdopt};
}

References GetInteropContext(), and impeller::interop::ImpellerContextRetain().

Referenced by OpenAssetAsHPPTexture().

◆ GetInteropContext()

ScopedObject< Context > impeller::interop::testing::PlaygroundTest::GetInteropContext ( )

Definition at line 171 of file playground_test.cc.

                                                        {
  if (interop_context_) {
    return interop_context_;
  }
 
  auto context = CreateSharedContext(GetBackend(), GetContext());
  if (!context) {
    return nullptr;
  }
  interop_context_ = std::move(context);
  return interop_context_;
}

References impeller::interop::testing::CreateSharedContext(), impeller::PlaygroundTest::GetBackend(), and impeller::Playground::GetContext().

Referenced by GetHPPContext(), and OpenPlaygroundHere().

◆ OpenAssetAsHPPMapping()

std::unique_ptr< hpp::Mapping > impeller::interop::testing::PlaygroundTest::OpenAssetAsHPPMapping ( std::string asset_name ) const

Definition at line 190 of file playground_test.cc.

                                {
  std::shared_ptr<fml::Mapping> data =
      OpenAssetAsMapping(std::move(asset_name));
  if (!data) {
    return nullptr;
  }
  return std::make_unique<hpp::Mapping>(data->GetMapping(),  //
                                        data->GetSize(),     //
                                        [data]() {}          //
  );
}

References impeller::PlaygroundTest::OpenAssetAsMapping().

◆ OpenAssetAsHPPTexture()

hpp::Texture impeller::interop::testing::PlaygroundTest::OpenAssetAsHPPTexture ( std::string asset_name )

Definition at line 203 of file playground_test.cc.

                                                                     {
  auto compressed_data = OpenAssetAsMapping(std::move(asset_name));
  if (!compressed_data) {
    return {nullptr, hpp::AdoptTag::kAdopt};
  }
  auto compressed_image =
      LoadFixtureImageCompressed(std::move(compressed_data));
  if (!compressed_image) {
    return {nullptr, hpp::AdoptTag::kAdopt};
  }
  auto decompressed_image = DecodeImageRGBA(compressed_image);
  if (!decompressed_image.has_value()) {
    return {nullptr, hpp::AdoptTag::kAdopt};
  }
  auto rgba_decompressed_image =
      std::make_shared<DecompressedImage>(decompressed_image->ConvertToRGBA());
  if (!rgba_decompressed_image || !rgba_decompressed_image->IsValid()) {
    return {nullptr, hpp::AdoptTag::kAdopt};
  }
  auto context = GetHPPContext();
  if (!context) {
    return {nullptr, hpp::AdoptTag::kAdopt};
  }
 
  auto rgba_mapping = std::make_unique<hpp::Mapping>(
      rgba_decompressed_image->GetAllocation()->GetMapping(),
      rgba_decompressed_image->GetAllocation()->GetSize(),
      [rgba_decompressed_image]() {});
 
  return hpp::Texture::WithContents(
      context,
      ImpellerTextureDescriptor{
          .pixel_format = kImpellerPixelFormatRGBA8888,
          .size = {rgba_decompressed_image->GetSize().width,
                   rgba_decompressed_image->GetSize().height},
          .mip_count = 1u,
      },
      std::move(rgba_mapping));
}

References impeller::Playground::DecodeImageRGBA(), GetHPPContext(), kImpellerPixelFormatRGBA8888, impeller::Playground::LoadFixtureImageCompressed(), impeller::PlaygroundTest::OpenAssetAsMapping(), ImpellerTextureDescriptor::pixel_format, and width.

◆ OpenPlaygroundHere()

bool impeller::interop::testing::PlaygroundTest::OpenPlaygroundHere ( InteropPlaygroundCallback callback )

Definition at line 129 of file playground_test.cc.

                                                                          {
  auto interop_context = GetInteropContext();
  if (!interop_context) {
    return false;
  }
  return Playground::OpenPlaygroundHere([&](RenderTarget& target) -> bool {
    auto impeller_surface = std::make_shared<impeller::Surface>(target);
    auto surface = CreateSharedSurface(GetBackend(),                //
                                       *interop_context.Get(),      //
                                       std::move(impeller_surface)  //
    );
    if (!surface) {
      VALIDATION_LOG << "Could not wrap test surface as an interop surface.";
      return false;
    }
    return callback(interop_context, surface);
  });
}

References callback, impeller::interop::testing::CreateSharedSurface(), impeller::PlaygroundTest::GetBackend(), GetInteropContext(), impeller::Playground::OpenPlaygroundHere(), surface, target, and VALIDATION_LOG.

◆ operator=()

PlaygroundTest & impeller::interop::testing::PlaygroundTest::operator= ( const PlaygroundTest & )

delete

◆ SetUp()

void impeller::interop::testing::PlaygroundTest::SetUp ( )

override

Definition at line 50 of file playground_test.cc.

                           {
  ::impeller::PlaygroundTest::SetUp();
}

References impeller::PlaygroundTest::SetUp().

◆ TearDown()

void impeller::interop::testing::PlaygroundTest::TearDown ( )