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. More...
bool	RunDartFunction (const char *dart_function_name)
	Invokes a Dart function. More...
bool	RunDartFunctionWithWindowSize (const char *dart_function_name)
	Invokes a Dart function with the window's width and height as arguments. More...
bool	RenderDartToPlayground (const char *dart_function_name)
	Call a dart function that produces a texture and render the result in the playground. More...
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
absl::StatusOr< RuntimeStage::Map >	OpenAssetAsRuntimeStage (const char *asset_name) const
std::string	GetWindowTitle () const override
Public Member Functions inherited from impeller::Playground
	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. More...
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
fml::Status	SetCapabilities (const std::shared_ptr< Capabilities > &capabilities)
bool	WillRenderSomething () const
	Returns true if OpenPlaygroundHere will actually render anything. More...
GLProcAddressResolver	CreateGLProcAddressResolver () const
VKProcAddressResolver	CreateVKProcAddressResolver () const
void	SetGPUDisabled (bool disabled) const
	Mark the GPU as unavilable. More...
RuntimeStageBackend	GetRuntimeStageBackend () const

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	TearDownContextData ()
virtual void	EnsureContextIsUnique ()
	Make sure that when the context is later created that it will not be shared with any other playgrounds. More...
bool	PlatformSupportsWideGamutTests () const
	Returns true if the platform can support wide gamuts. More...
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. More...
virtual void	EnsureContextSupportsAntialiasLines ()
	Make sure that when the context is later created that it will support the experimental AA lines flag. More...
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. More...
void	SetTypographerContext (std::shared_ptr< TypographerContext > typographer_context)
void	SetWindowSize (ISize size)

Detailed Description

Definition at line 57 of file renderer_dart_unittests.cc.

Constructor & Destructor Documentation

RendererDartTest()

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

inline

Definition at line 60 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));
    }
  }

Member Function Documentation

GetIsolate()

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

inline

Definition at line 89 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(), and impeller::testing::InstantiateTestShaderLibrary().

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 101 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 DrainMicrotasks();
        });
    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 impeller::testing::DrainMicrotasks(), GetIsolate(), and impeller::Playground::GetWindowSize().

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 166 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(), context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Playground::GetContext(), GetRenderedTextureFromDart(), impeller::Playground::IsPlaygroundEnabled(), impeller::kCount4, impeller::kUnknown, impeller::Playground::OpenPlaygroundHere(), pipeline, and RunDartFunctionWithWindowSize().

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 131 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 DrainMicrotasks();
    });
  }

References impeller::testing::DrainMicrotasks(), and GetIsolate().

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 147 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 DrainMicrotasks();
        });
  }

References impeller::testing::DrainMicrotasks(), GetIsolate(), and impeller::Playground::GetWindowSize().

Referenced by RenderDartToPlayground().

---

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

• impeller/renderer/renderer_dart_unittests.cc