node.h

Go to the documentation of this file.

#ifndef ION_GFX_NODE_H_
#define ION_GFX_NODE_H_

#include "ion/base/invalid.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/shaderprogram.h"
#include "ion/gfx/shape.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/uniformblock.h"

namespace ion {
namespace gfx {

class Node;
typedef base::ReferentPtr<Node>::Type NodePtr;

class ION_API Node : public base::Referent, public UniformHolder {
 public:
  Node();

  const std::string& GetLabel() const { return label_; }
  void SetLabel(const std::string& label) { label_ = label; }

  void SetStateTable(const StateTablePtr& state_table) {
    state_table_ = state_table;
  }
  const StateTablePtr& GetStateTable() const { return state_table_; }

  void SetShaderProgram(const ShaderProgramPtr& shader_program) {
    shader_program_ = shader_program;
  }
  const ShaderProgramPtr& GetShaderProgram() const { return shader_program_; }

  void AddUniformBlock(const UniformBlockPtr& block) {
    if (block.Get())
      uniform_blocks_.push_back(block);
  }
  void ReplaceUniformBlock(size_t index, const UniformBlockPtr& block) {
    if (index < uniform_blocks_.size() && block.Get())
      uniform_blocks_[index] = block;
  }
  void ClearUniformBlocks() { uniform_blocks_.clear(); }
  const base::AllocVector<UniformBlockPtr>& GetUniformBlocks() const {
    return uniform_blocks_;
  }

  size_t AddShape(const ShapePtr& shape) {
    size_t index = base::kInvalidIndex;
    if (shape.Get()) {
      index = shapes_.size();
      shapes_.push_back(shape);
    }
    return index;
  }
  void ReplaceShape(size_t index, const ShapePtr& shape) {
    if (index < shapes_.size() && shape.Get())
      shapes_[index] = shape;
  }
  void RemoveShape(const ShapePtr& shape) {
    for (auto it = shapes_.begin(); it != shapes_.end();) {
      if (*it == shape)
        it = shapes_.erase(it);
      else
        ++it;
    }
  }
  void RemoveShapeAt(size_t index) {
    if (index < shapes_.size()) {
      auto it = shapes_.begin() + index;
      shapes_.erase(it);
    }
  }
  void ClearShapes() { shapes_.clear(); }
  const base::AllocVector<ShapePtr>& GetShapes() const { return shapes_; }

  size_t AddChild(const NodePtr& child) {
    size_t index = base::kInvalidIndex;
    if (child.Get()) {
      index = children_.size();
      children_.push_back(child);
    }
    return index;
  }
  void ReplaceChild(size_t index, const NodePtr& child) {
    if (index < children_.size() && child.Get())
      children_[index] = child;
  }
  void RemoveChild(const NodePtr& child) {
    for (auto it = children_.begin(); it != children_.end();) {
      if (*it == child)
        it = children_.erase(it);
      else
        ++it;
    }
  }
  void RemoveChildAt(size_t index) {
    if (index < children_.size()) {
      auto it = children_.begin() + index;
      children_.erase(it);
    }
  }
  void ClearChildren() { children_.clear(); }
  const base::AllocVector<NodePtr>& GetChildren() const { return children_; }

 protected:
  ~Node() override;

 private:
  StateTablePtr state_table_;
  ShaderProgramPtr shader_program_;
  base::AllocVector<ShapePtr> shapes_;
  base::AllocVector<NodePtr> children_;
  base::AllocVector<UniformBlockPtr> uniform_blocks_;
  std::string label_;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_NODE_H_