flutter::SceneNode Class Reference

A scene node, which may be a deserialized ipscene asset. This node can be safely added as a child to multiple scene nodes, whether they're in the same scene or a different scene. The deserialized node itself is treated as immutable on the IO thread. More...

#include <scene_node.h>

Inheritance diagram for flutter::SceneNode:

Public Member Functions
	SceneNode ()
	~SceneNode () override
std::string	initFromAsset (const std::string &asset_name, Dart_Handle completion_callback_handle)
void	initFromTransform (const tonic::Float64List &matrix4)
void	AddChild (Dart_Handle scene_node_handle)
void	SetTransform (const tonic::Float64List &matrix4)
void	SetAnimationState (const std::string &animation_name, bool playing, bool loop, double weight, double time_scale)
void	SeekAnimation (const std::string &animation_name, double time)
fml::RefPtr< SceneNode >	node (Dart_Handle shader)
Public Member Functions inherited from flutter::RefCountedDartWrappable< SceneNode >
virtual void	RetainDartWrappableReference () const override
virtual void	ReleaseDartWrappableReference () const override
Public Member Functions inherited from fml::RefCountedThreadSafe< T >
void	Release () const
Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const
Public Member Functions inherited from tonic::DartWrappable
	DartWrappable ()
virtual const DartWrapperInfo &	GetDartWrapperInfo () const =0
Dart_Handle	CreateDartWrapper (DartState *dart_state)
void	AssociateWithDartWrapper (Dart_Handle wrappable)
void	ClearDartWrapper ()
Dart_WeakPersistentHandle	dart_wrapper () const

Static Public Member Functions
static void	Create (Dart_Handle wrapper)

Additional Inherited Members
Public Types inherited from tonic::DartWrappable
enum	DartNativeFields { kPeerIndex , kNumberOfNativeFields }
Protected Member Functions inherited from fml::RefCountedThreadSafe< T >
	RefCountedThreadSafe ()
	~RefCountedThreadSafe ()
Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()
Protected Member Functions inherited from tonic::DartWrappable
virtual	~DartWrappable ()
Static Protected Member Functions inherited from tonic::DartWrappable
static Dart_PersistentHandle	GetTypeForWrapper (tonic::DartState *dart_state, const tonic::DartWrapperInfo &wrapper_info)

Detailed Description

A scene node, which may be a deserialized ipscene asset. This node can be safely added as a child to multiple scene nodes, whether they're in the same scene or a different scene. The deserialized node itself is treated as immutable on the IO thread.

Internally, nodes may have an animation player, which is controlled via the mutation log in the DlSceneColorSource, which is built by SceneShader.

Definition at line 30 of file scene_node.h.

Constructor & Destructor Documentation

SceneNode()

flutter::SceneNode::SceneNode ( )

default

~SceneNode()

flutter::SceneNode::~SceneNode ( )

overridedefault

Member Function Documentation

AddChild()

void flutter::SceneNode::AddChild

(

Dart_Handle

scene_node_handle

)

Definition at line 126 of file scene_node.cc.

                                                      {
  if (!node_) {
    return;
  }
  auto* scene_node =
      tonic::DartConverter<SceneNode*>::FromDart(scene_node_handle);
  if (!scene_node) {
    return;
  }
  node_->AddChild(scene_node->node_);
  children_.push_back(fml::Ref(scene_node));
}

Create()

void flutter::SceneNode::Create ( Dart_Handle  wrapper )

static

Definition at line 30 of file scene_node.cc.

                                          {
  auto res = fml::MakeRefCounted<SceneNode>();
  res->AssociateWithDartWrapper(wrapper);
}

initFromAsset()

std::string flutter::SceneNode::initFromAsset	(	const std::string &	asset_name,
		Dart_Handle	completion_callback_handle
	)

Definition at line 35 of file scene_node.cc.

                                                                             {
  FML_TRACE_EVENT("flutter", "SceneNode::initFromAsset", "asset", asset_name);
 
  if (!Dart_IsClosure(completion_callback_handle)) {
    return "Completion callback must be a function.";
  }
 
  auto dart_state = UIDartState::Current();
  if (!dart_state->IsImpellerEnabled()) {
    return "3D scenes require the Impeller rendering backend to be enabled.";
  }
 
  std::shared_ptr<AssetManager> asset_manager =
      dart_state->platform_configuration()->client()->GetAssetManager();
  std::unique_ptr<fml::Mapping> data = asset_manager->GetAsMapping(asset_name);
  if (data == nullptr) {
    return std::string("Asset '") + asset_name + std::string("' not found.");
  }
 
  auto& task_runners = dart_state->GetTaskRunners();
 
  std::promise<std::shared_ptr<impeller::Context>> context_promise;
  auto impeller_context_promise = context_promise.get_future();
  task_runners.GetIOTaskRunner()->PostTask(
      fml::MakeCopyable([promise = std::move(context_promise),
                         io_manager = dart_state->GetIOManager()]() mutable {
        promise.set_value(io_manager ? io_manager->GetImpellerContext()
                                     : nullptr);
      }));
 
  auto persistent_completion_callback =
      std::make_unique<tonic::DartPersistentValue>(dart_state,
                                                   completion_callback_handle);
 
  auto ui_task = fml::MakeCopyable(
      [this, callback = std::move(persistent_completion_callback)](
          std::shared_ptr<impeller::scene::Node> node) mutable {
        auto dart_state = callback->dart_state().lock();
        if (!dart_state) {
          // The root isolate could have died in the meantime.
          return;
        }
        tonic::DartState::Scope scope(dart_state);
 
        node_ = std::move(node);
        tonic::DartInvoke(callback->Get(), {Dart_TypeVoid()});
 
        // callback is associated with the Dart isolate and must be
        // deleted on the UI thread.
        callback.reset();
      });
 
  task_runners.GetRasterTaskRunner()->PostTask(
      fml::MakeCopyable([ui_task = std::move(ui_task), task_runners,
                         impeller_context = impeller_context_promise.get(),
                         data = std::move(data)]() {
        auto node = impeller::scene::Node::MakeFromFlatbuffer(
            *data, *impeller_context->GetResourceAllocator());
 
        task_runners.GetUITaskRunner()->PostTask(
            [ui_task, node = std::move(node)]() { ui_task(node); });
      }));
 
  return "";
}

initFromTransform()

void flutter::SceneNode::initFromTransform

(

const tonic::Float64List &

matrix4

)

Definition at line 121 of file scene_node.cc.

                                                                 {
  node_ = std::make_shared<impeller::scene::Node>();
  node_->SetLocalTransform(ToMatrix(matrix4));
}

node()

fml::RefPtr< SceneNode > flutter::SceneNode::node

(

Dart_Handle

shader

)

SeekAnimation()

void flutter::SceneNode::SeekAnimation	(	const std::string &	animation_name,
		double	time
	)

Definition at line 160 of file scene_node.cc.

                                                                          {
  impeller::scene::Node::MutationLog::SeekAnimationEntry entry = {
      .animation_name = animation_name,
      .time = static_cast<float>(time),
  };
  node_->AddMutation(entry);
}

SetAnimationState()

void flutter::SceneNode::SetAnimationState	(	const std::string &	animation_name,
		bool	playing,
		bool	loop,
		double	weight,
		double	time_scale
	)

Definition at line 145 of file scene_node.cc.

                                                     {
  impeller::scene::Node::MutationLog::SetAnimationStateEntry entry = {
      .animation_name = animation_name,
      .playing = playing,
      .loop = loop,
      .weight = static_cast<float>(weight),
      .time_scale = static_cast<float>(time_scale),
  };
  node_->AddMutation(entry);
}

SetTransform()

void flutter::SceneNode::SetTransform

(

const tonic::Float64List &

matrix4

)

Definition at line 139 of file scene_node.cc.

                                                            {
  impeller::scene::Node::MutationLog::SetTransformEntry entry = {
      ToMatrix(matrix4)};
  node_->AddMutation(entry);
}

---

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

• lib/ui/painting/scene/scene_node.h
• lib/ui/painting/scene/scene_node.cc