impeller::scene::Node Class Reference

#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 26 of file node.h.

Constructor & Destructor Documentation

Node()

Node::Node

(

)

Definition at line 224 of file node.cc.

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

~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