impeller::testing::RendererDartTest Class Reference

Inheritance diagram for impeller::testing::RendererDartTest:

Public Member Functions
	RendererDartTest ()
flutter::testing::AutoIsolateShutdown *	GetIsolate ()
std::shared_ptr< Texture >	GetRenderedTextureFromDart (const char *dart_function_name)
	Run a Dart function that's expected to create a texture and pass it back for rendering via drawToPlayground.
bool	RunDartFunction (const char *dart_function_name)
	Invokes a Dart function.
bool	RunDartFunctionWithWindowSize (const char *dart_function_name)
	Invokes a Dart function with the window's width and height as arguments.
bool	RenderDartToPlayground (const char *dart_function_name)
	Call a dart function that produces a texture and render the result in the playground.
Public Member Functions inherited from impeller::PlaygroundTest
	PlaygroundTest ()
virtual	~PlaygroundTest ()
void	SetUp () override
void	TearDown () override
PlaygroundBackend	GetBackend () const
std::unique_ptr< fml::Mapping >	OpenAssetAsMapping (std::string asset_name) const override
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
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.
Public Member Functions inherited from flutter::testing::DartFixture
	DartFixture ()
	DartFixture (std::string kernel_filename, std::string elf_filename, std::string elf_split_filename)
virtual Settings	CreateSettingsForFixture ()
void	AddNativeCallback (const std::string &name, Dart_NativeFunction callback)
void	AddFfiNativeCallback (const std::string &name, void *callback_ptr)

Additional Inherited Members
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)>
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 Member Functions inherited from flutter::testing::DartFixture
void	SetSnapshotsAndAssets (Settings &settings)
Protected Attributes inherited from impeller::Playground
const PlaygroundSwitches	switches_
Protected Attributes inherited from flutter::testing::DartFixture
std::shared_ptr< TestDartNativeResolver >	native_resolver_
ELFAOTSymbols	split_aot_symbols_
std::string	kernel_filename_
std::string	elf_filename_
fml::UniqueFD	assets_dir_
ELFAOTSymbols	aot_symbols_

Detailed Description

Definition at line 42 of file renderer_dart_unittests.cc.

Constructor & Destructor Documentation

RendererDartTest()

impeller::testing::RendererDartTest::RendererDartTest ( )

inline

Definition at line 45 of file renderer_dart_unittests.cc.

      : settings_(CreateSettingsForFixture()),
        vm_ref_(flutter::DartVMRef::Create(settings_)) {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
 
    current_task_runner_ = fml::MessageLoop::GetCurrent().GetTaskRunner();
 
    isolate_ = CreateDartIsolate();
    assert(isolate_);
    assert(isolate_->get()->GetPhase() == flutter::DartIsolate::Phase::Running);
 
    // Set up native callbacks.
    //
    // Note: The Dart isolate is configured (by
    //       `RendererDartTest::CreateDartIsolate`) to use the main thread, so
    //       there's no need for additional synchronization.
    {
      auto set_display_texture = [this](Dart_NativeArguments args) {
        flutter::gpu::Texture* texture =
            tonic::DartConverter<flutter::gpu::Texture*>::FromDart(
                Dart_GetNativeArgument(args, 0));
        assert(texture != nullptr);  // Should always be a valid pointer.
        received_texture_ = texture->GetTexture();
      };
      AddNativeCallback("SetDisplayTexture",
                        CREATE_NATIVE_ENTRY(set_display_texture));
    }
  }

References flutter::testing::DartFixture::AddNativeCallback(), args, CREATE_NATIVE_ENTRY, fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), fml::MessageLoop::GetTaskRunner(), flutter::DartIsolate::Running, and texture.

Member Function Documentation

GetIsolate()

flutter::testing::AutoIsolateShutdown * impeller::testing::RendererDartTest::GetIsolate ( )

inline

Definition at line 74 of file renderer_dart_unittests.cc.

                                                  {
    // Sneak the context into the Flutter GPU API.
    assert(GetContext() != nullptr);
    flutter::gpu::Context::SetOverrideContext(GetContext());
 
    InstantiateTestShaderLibrary(GetContext()->GetBackendType());
 
    return isolate_.get();
  }

References impeller::Playground::GetContext(), impeller::testing::InstantiateTestShaderLibrary(), and flutter::gpu::Context::SetOverrideContext().

Referenced by GetRenderedTextureFromDart(), RunDartFunction(), and RunDartFunctionWithWindowSize().

GetRenderedTextureFromDart()

std::shared_ptr< Texture > impeller::testing::RendererDartTest::GetRenderedTextureFromDart ( const char *  dart_function_name )

inline

Run a Dart function that's expected to create a texture and pass it back for rendering via drawToPlayground.

Definition at line 86 of file renderer_dart_unittests.cc.

                                      {
    bool success =
        GetIsolate()->RunInIsolateScope([this, &dart_function_name]() -> bool {
          Dart_Handle args[] = {tonic::ToDart(GetWindowSize().width),
                                tonic::ToDart(GetWindowSize().height)};
          if (tonic::CheckAndHandleError(
                  ::Dart_Invoke(Dart_RootLibrary(),
                                tonic::ToDart(dart_function_name), 2, args))) {
            return false;
          }
          return true;
        });
    if (!success) {
      FML_LOG(ERROR) << "Failed to invoke dart test function:"
                     << dart_function_name;
      return nullptr;
    }
    if (!received_texture_) {
      FML_LOG(ERROR) << "Dart test function `" << dart_function_name
                     << "` did not invoke `drawToPlaygroundSurface`.";
      return nullptr;
    }
    return received_texture_;
  }

References args, tonic::CheckAndHandleError(), FML_LOG, GetIsolate(), impeller::Playground::GetWindowSize(), height, flutter::testing::AutoIsolateShutdown::RunInIsolateScope(), tonic::ToDart(), and width.

Referenced by RenderDartToPlayground().

RenderDartToPlayground()

bool impeller::testing::RendererDartTest::RenderDartToPlayground ( const char *  dart_function_name )

inline

Call a dart function that produces a texture and render the result in the playground.

If the playground isn't enabled, the function is simply run once in order to verify that it doesn't throw any unhandled exceptions.

Prepare pipeline.

Prepare vertex data.

Prepare sampler.

Render to playground.

Definition at line 151 of file renderer_dart_unittests.cc.

                                                              {
    if (!IsPlaygroundEnabled()) {
      // If the playground is not enabled, run the function instead to at least
      // verify that it doesn't crash.
      return RunDartFunctionWithWindowSize(dart_function_name);
    }
 
    auto context = GetContext();
    assert(context != nullptr);
 
    //------------------------------------------------------------------------------
    /// Prepare pipeline.
    ///
 
    using TextureVS = TextureVertexShader;
    using TextureFS = TextureFragmentShader;
    using TexturePipelineBuilder = PipelineBuilder<TextureVS, TextureFS>;
 
    auto pipeline_desc =
        TexturePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
    if (!pipeline_desc.has_value()) {
      FML_LOG(ERROR) << "Failed to create default pipeline descriptor.";
      return false;
    }
    pipeline_desc->SetSampleCount(SampleCount::kCount4);
    pipeline_desc->SetStencilAttachmentDescriptors(std::nullopt);
    pipeline_desc->SetDepthStencilAttachmentDescriptor(std::nullopt);
    pipeline_desc->SetStencilPixelFormat(PixelFormat::kUnknown);
    pipeline_desc->SetDepthPixelFormat(PixelFormat::kUnknown);
 
    auto pipeline =
        context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
    if (!pipeline || !pipeline->IsValid()) {
      FML_LOG(ERROR) << "Failed to create default pipeline.";
      return false;
    }
 
    //------------------------------------------------------------------------------
    /// Prepare vertex data.
    ///
 
    VertexBufferBuilder<TextureVS::PerVertexData> texture_vtx_builder;
 
    // Always stretch out the texture to fill the screen.
 
    // clang-format off
    texture_vtx_builder.AddVertices({
        {{-0.5, -0.5, 0.0}, {0.0, 0.0}},  // 1
        {{ 0.5, -0.5, 0.0}, {1.0, 0.0}},  // 2
        {{ 0.5,  0.5, 0.0}, {1.0, 1.0}},  // 3
        {{-0.5, -0.5, 0.0}, {0.0, 0.0}},  // 1
        {{ 0.5,  0.5, 0.0}, {1.0, 1.0}},  // 3
        {{-0.5,  0.5, 0.0}, {0.0, 1.0}},  // 4
    });
    // clang-format on
 
    //------------------------------------------------------------------------------
    /// Prepare sampler.
    ///
 
    const auto& sampler = context->GetSamplerLibrary()->GetSampler({});
    if (!sampler) {
      FML_LOG(ERROR) << "Failed to create default sampler.";
      return false;
    }
 
    //------------------------------------------------------------------------------
    /// Render to playground.
    ///
 
    SinglePassCallback callback = [&](RenderPass& pass) {
      auto texture = GetRenderedTextureFromDart(dart_function_name);
      if (!texture) {
        return false;
      }
 
      auto buffer = HostBuffer::Create(
          context->GetResourceAllocator(), context->GetIdleWaiter(),
          context->GetCapabilities()->GetMinimumUniformAlignment());
 
      pass.SetVertexBuffer(texture_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
 
      TextureVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix();
      TextureVS::BindUniformBuffer(pass, buffer->EmplaceUniform(uniforms));
      TextureFS::BindTextureContents(pass, texture, sampler);
 
      pass.SetPipeline(pipeline);
 
      if (!pass.Draw().ok()) {
        return false;
      }
      return true;
    };
    return OpenPlaygroundHere(callback);
  }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), flutter::buffer, callback, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), FML_LOG, impeller::Playground::GetContext(), GetRenderedTextureFromDart(), impeller::Playground::IsPlaygroundEnabled(), impeller::kCount4, impeller::kUnknown, impeller::Playground::OpenPlaygroundHere(), RunDartFunctionWithWindowSize(), and texture.

RunDartFunction()

bool impeller::testing::RendererDartTest::RunDartFunction ( const char *  dart_function_name )

inline

Invokes a Dart function.

    Returns false if invoking the function failed or if any unhandled
    exceptions were thrown. 

Definition at line 116 of file renderer_dart_unittests.cc.

                                                       {
    return GetIsolate()->RunInIsolateScope([&dart_function_name]() -> bool {
      if (tonic::CheckAndHandleError(
              ::Dart_Invoke(Dart_RootLibrary(),
                            tonic::ToDart(dart_function_name), 0, nullptr))) {
        return false;
      }
      return true;
    });
  }

References tonic::CheckAndHandleError(), GetIsolate(), flutter::testing::AutoIsolateShutdown::RunInIsolateScope(), and tonic::ToDart().

RunDartFunctionWithWindowSize()

bool impeller::testing::RendererDartTest::RunDartFunctionWithWindowSize ( const char *  dart_function_name )

inline

Invokes a Dart function with the window's width and height as arguments.

Returns false if invoking the function failed or if any unhandled exceptions were thrown.

Definition at line 132 of file renderer_dart_unittests.cc.

                                                                     {
    return GetIsolate()->RunInIsolateScope(
        [this, &dart_function_name]() -> bool {
          Dart_Handle args[] = {tonic::ToDart(GetWindowSize().width),
                                tonic::ToDart(GetWindowSize().height)};
          if (tonic::CheckAndHandleError(
                  ::Dart_Invoke(Dart_RootLibrary(),
                                tonic::ToDart(dart_function_name), 2, args))) {
            return false;
          }
          return true;
        });
  }

References args, tonic::CheckAndHandleError(), GetIsolate(), impeller::Playground::GetWindowSize(), height, flutter::testing::AutoIsolateShutdown::RunInIsolateScope(), tonic::ToDart(), and width.

Referenced by RenderDartToPlayground().

---

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

• impeller/renderer/renderer_dart_unittests.cc