#include <node.h>

Classes
class	MutationLog

Public Member Functions
	Node ()

	~Node ()

const std::string &	GetName () const

void	SetName (const std::string &new_name)

Node *	GetParent () const

std::shared_ptr< Node >	FindChildByName (const std::string &name, bool exclude_animation_players=false) const

std::shared_ptr< Animation >	FindAnimationByName (const std::string &name) const

AnimationClip *	AddAnimation (const std::shared_ptr< Animation > &animation)

void	SetLocalTransform (Matrix transform)

Matrix	GetLocalTransform () const

void	SetGlobalTransform (Matrix transform)

Matrix	GetGlobalTransform () const

bool	AddChild (std::shared_ptr< Node > child)

std::vector< std::shared_ptr< Node > > &	GetChildren ()

void	SetMesh (Mesh mesh)

Mesh &	GetMesh ()

void	SetIsJoint (bool is_joint)

bool	IsJoint () const

bool	Render (SceneEncoder &encoder, Allocator &allocator, const Matrix &parent_transform)

void	AddMutation (const MutationLog::Entry &entry)

Static Public Member Functions
static std::shared_ptr< Node >	MakeFromFlatbuffer (const fml::Mapping &ipscene_mapping, Allocator &allocator)

static std::shared_ptr< Node >	MakeFromFlatbuffer (const fb::Scene &scene, Allocator &allocator)

Detailed Description

Definition at line 30 of file node.h.

Constructor & Destructor Documentation

◆ Node()

Node::Node ( )

Definition at line 224 of file node.cc.

224: name_(SPrintF("__node%" PRIu64, kNextNodeID++)){};

impeller::scene::kNextNodeID

static std::atomic_uint64_t kNextNodeID

Definition node.cc:27

impeller::SPrintF

std::string SPrintF(const char *format,...)

Definition strings.cc:12

◆ ~Node()

Node::~Node ( )

default

Member Function Documentation

◆ AddAnimation()

AnimationClip * Node::AddAnimation ( const std::shared_ptr< Animation > & animation )

Definition at line 271 of file node.cc.

                                                                           {
  if (!animation_player_.has_value()) {
    animation_player_ = AnimationPlayer();
  }
  return animation_player_->AddAnimation(animation, this);
}

◆ AddChild()

bool Node::AddChild ( std::shared_ptr< Node > child )

Definition at line 300 of file node.cc.

                                            {
  if (!node) {
    VALIDATION_LOG << "Cannot add null child to node.";
    return false;
  }
 
  // TODO(bdero): Figure out a better paradigm/rules for nodes with multiple
  //              parents. We should probably disallow this, make deep
  //              copying of nodes cheap and easy, add mesh instancing, etc.
  //              Today, the parent link is only used for skin posing, and so
  //              it's reasonable to not have a check and allow multi-parenting.
  //              Even still, there should still be some kind of cycle
  //              prevention/detection, ideally at the protocol level.
  //
  // if (node->parent_ != nullptr) {
  //   VALIDATION_LOG
  //       << "Cannot add a node as a child which already has a parent.";
  //   return false;
  // }
  node->parent_ = this;
  children_.push_back(std::move(node));
 
  return true;
}

◆ AddMutation()

void Node::AddMutation ( const MutationLog::Entry & entry )

Definition at line 412 of file node.cc.

                                                    {
  mutation_log_.Append(entry);
}

◆ FindAnimationByName()

std::shared_ptr< Animation > Node::FindAnimationByName ( const std::string & name ) const

Definition at line 261 of file node.cc.

                                 {
  for (const auto& animation : animations_) {
    if (animation->GetName() == name) {
      return animation;
    }
  }
  return nullptr;
}

◆ FindChildByName()

std::shared_ptr< Node > Node::FindChildByName	(	const std::string &	name,
		bool	exclude_animation_players = `false`
	)		const

Definition at line 244 of file node.cc.

                                          {
  for (auto& child : children_) {
    if (exclude_animation_players && child->animation_player_.has_value()) {
      continue;
    }
    if (child->GetName() == name) {
      return child;
    }
    if (auto found = child->FindChildByName(name)) {
      return found;
    }
  }
  return nullptr;
}

◆ GetChildren()

std::vector< std::shared_ptr< Node > > & Node::GetChildren ( )

Definition at line 325 of file node.cc.

                                                  {
  return children_;
}

◆ GetGlobalTransform()

Matrix Node::GetGlobalTransform ( ) const

Definition at line 293 of file node.cc.

                                      {
  if (parent_) {
    return parent_->GetGlobalTransform() * local_transform_;
  }
  return local_transform_;
}

◆ GetLocalTransform()

Matrix Node::GetLocalTransform ( ) const

Definition at line 282 of file node.cc.

                                     {
  return local_transform_;
}

◆ GetMesh()

Mesh & Node::GetMesh ( )

Definition at line 333 of file node.cc.

                    {
  return mesh_;
}

◆ GetName()

const std::string & Node::GetName ( ) const

Definition at line 232 of file node.cc.

                                     {
  return name_;
}

◆ GetParent()

Node * Node::GetParent ( ) const

Definition at line 240 of file node.cc.

                            {
  return parent_;
}

◆ IsJoint()

bool Node::IsJoint ( ) const

Definition at line 341 of file node.cc.

                         {
  return is_joint_;
}

◆ MakeFromFlatbuffer() [1/2]

std::shared_ptr< Node > Node::MakeFromFlatbuffer	(	const fb::Scene &	scene,
		Allocator &	allocator
	)

static

Definition at line 126 of file node.cc.

                                                                     {
  // Unpack textures.
  std::vector<std::shared_ptr<Texture>> textures;
  if (scene.textures()) {
    for (const auto iptexture : *scene.textures()) {
      // The elements of the unpacked texture array must correspond exactly with
      // the ipscene texture array. So if a texture is empty or invalid, a
      // nullptr is inserted as a placeholder.
      textures.push_back(UnpackTextureFromFlatbuffer(iptexture, allocator));
    }
  }
 
  auto result = std::make_shared<Node>();
  result->SetLocalTransform(importer::ToMatrix(*scene.transform()));
 
  if (!scene.nodes() || !scene.children()) {
    return result;  // The scene is empty.
  }
 
  // Initialize nodes for unpacking the entire scene.
  std::vector<std::shared_ptr<Node>> scene_nodes;
  scene_nodes.reserve(scene.nodes()->size());
  for (size_t node_i = 0; node_i < scene.nodes()->size(); node_i++) {
    scene_nodes.push_back(std::make_shared<Node>());
  }
 
  // Connect children to the root node.
  for (int child : *scene.children()) {
    if (child < 0 || static_cast<size_t>(child) >= scene_nodes.size()) {
      VALIDATION_LOG << "Scene child index out of range.";
      continue;
    }
    result->AddChild(scene_nodes[child]);
  }
 
  // Unpack each node.
  for (size_t node_i = 0; node_i < scene.nodes()->size(); node_i++) {
    scene_nodes[node_i]->UnpackFromFlatbuffer(*scene.nodes()->Get(node_i),
                                              scene_nodes, textures, allocator);
  }
 
  // Unpack animations.
  if (scene.animations()) {
    for (const auto animation : *scene.animations()) {
      if (auto out_animation =
              Animation::MakeFromFlatbuffer(*animation, scene_nodes)) {
        result->animations_.push_back(out_animation);
      }
    }
  }
 
  return result;
}

◆ MakeFromFlatbuffer() [2/2]

std::shared_ptr< Node > Node::MakeFromFlatbuffer	(	const fml::Mapping &	ipscene_mapping,
		Allocator &	allocator
	)

static

Definition at line 47 of file node.cc.

                          {
  flatbuffers::Verifier verifier(ipscene_mapping.GetMapping(),
                                 ipscene_mapping.GetSize());
  if (!fb::VerifySceneBuffer(verifier)) {
    VALIDATION_LOG << "Failed to unpack scene: Scene flatbuffer is invalid.";
    return nullptr;
  }
 
  return Node::MakeFromFlatbuffer(*fb::GetScene(ipscene_mapping.GetMapping()),
                                  allocator);
}

◆ Render()

bool Node::Render	(	SceneEncoder &	encoder,
		Allocator &	allocator,
		const Matrix &	parent_transform
	)

Definition at line 345 of file node.cc.

                                                  {
  std::optional<std::vector<MutationLog::Entry>> log = mutation_log_.Flush();
  if (log.has_value()) {
    for (const auto& entry : log.value()) {
      if (auto e = std::get_if<MutationLog::SetTransformEntry>(&entry)) {
        local_transform_ = e->transform;
      } else if (auto e =
                     std::get_if<MutationLog::SetAnimationStateEntry>(&entry)) {
        AnimationClip* clip =
            animation_player_.has_value()
                ? animation_player_->GetClip(e->animation_name)
                : nullptr;
        if (!clip) {
          auto animation = FindAnimationByName(e->animation_name);
          if (!animation) {
            continue;
          }
          clip = AddAnimation(animation);
          if (!clip) {
            continue;
          }
        }
 
        clip->SetPlaying(e->playing);
        clip->SetLoop(e->loop);
        clip->SetWeight(e->weight);
        clip->SetPlaybackTimeScale(e->time_scale);
      } else if (auto e =
                     std::get_if<MutationLog::SeekAnimationEntry>(&entry)) {
        AnimationClip* clip =
            animation_player_.has_value()
                ? animation_player_->GetClip(e->animation_name)
                : nullptr;
        if (!clip) {
          auto animation = FindAnimationByName(e->animation_name);
          if (!animation) {
            continue;
          }
          clip = AddAnimation(animation);
          if (!clip) {
            continue;
          }
        }
 
        clip->Seek(SecondsF(e->time));
      }
    }
  }
 
  if (animation_player_.has_value()) {
    animation_player_->Update();
  }
 
  Matrix transform = parent_transform * local_transform_;
  mesh_.Render(encoder, transform,
               skin_ ? skin_->GetJointsTexture(allocator) : nullptr);
 
  for (auto& child : children_) {
    if (!child->Render(encoder, allocator, transform)) {
      return false;
    }
  }
  return true;
}

◆ SetGlobalTransform()

void Node::SetGlobalTransform ( Matrix transform )

Definition at line 286 of file node.cc.

                                              {
  Matrix inverse_global_transform =
      parent_ ? parent_->GetGlobalTransform().Invert() : Matrix();
 
  local_transform_ = inverse_global_transform * transform;
}

◆ SetIsJoint()

void Node::SetIsJoint ( bool is_joint )

Definition at line 337 of file node.cc.

                                   {
  is_joint_ = is_joint;
}

◆ SetLocalTransform()

void Node::SetLocalTransform ( Matrix transform )

Definition at line 278 of file node.cc.

                                             {
  local_transform_ = transform;
}

◆ SetMesh()

void Node::SetMesh ( Mesh mesh )

Definition at line 329 of file node.cc.

                            {
  mesh_ = std::move(mesh);
}

◆ SetName()

void Node::SetName ( const std::string & new_name )

Definition at line 236 of file node.cc.

                                            {
  name_ = new_name;
}

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

impeller/scene/node.h
impeller/scene/node.cc

Classes

Public Member Functions

Static Public Member Functions