Model.h

#pragma once
 
#include <CesiumGltf/Library.h>
#include <CesiumGltf/ModelSpec.h>
#include <CesiumUtility/ErrorList.h>
 
#include <glm/mat4x4.hpp>
 
#include <functional>
 
namespace CesiumGltf {
 
struct CESIUMGLTF_API Model : public ModelSpec {
  Model() = default;
 
  CesiumUtility::ErrorList merge(Model&& rhs);
 
  typedef void ForEachRootNodeInSceneCallback(Model& gltf, Node& node);
 
  typedef void
  ForEachRootNodeInSceneConstCallback(const Model& gltf, const Node& node);
 
  void forEachRootNodeInScene(
      int32_t sceneID,
      std::function<ForEachRootNodeInSceneCallback>&& callback);
 
  void forEachRootNodeInScene(
      int32_t sceneID,
      std::function<ForEachRootNodeInSceneConstCallback>&& callback) const;
 
  typedef void ForEachNodeInSceneCallback(
      Model& gltf,
      Node& node,
      const glm::dmat4& transform);
 
  void forEachNodeInScene(
      int32_t sceneID,
      std::function<ForEachNodeInSceneCallback>&& callback);
 
  typedef void ForEachNodeInSceneConstCallback(
      const Model& gltf,
      const Node& node,
      const glm::dmat4& transform);
 
  void forEachNodeInScene(
      int32_t sceneID,
      std::function<ForEachNodeInSceneConstCallback>&& callback) const;
 
  typedef void ForEachPrimitiveInSceneCallback(
      Model& gltf,
      Node& node,
      Mesh& mesh,
      MeshPrimitive& primitive,
      const glm::dmat4& transform);
 
  void forEachPrimitiveInScene(
      int32_t sceneID,
      std::function<ForEachPrimitiveInSceneCallback>&& callback);
 
  typedef void ForEachPrimitiveInSceneConstCallback(
      const Model& gltf,
      const Node& node,
      const Mesh& mesh,
      const MeshPrimitive& primitive,
      const glm::dmat4& transform);
 
  void forEachPrimitiveInScene(
      int32_t sceneID,
      std::function<ForEachPrimitiveInSceneConstCallback>&& callback) const;
 
  void generateMissingNormalsSmooth();
 
  template <typename T>
  static const T& getSafe(const std::vector<T>& items, int32_t index) {
    static T defaultObject;
    if (index < 0 || size_t(index) >= items.size()) {
      return defaultObject;
    } else {
      return items[size_t(index)];
    }
  }
 
  template <typename T>
  static const T*
  getSafe(const std::vector<T>* pItems, int32_t index) noexcept {
    if (index < 0 || size_t(index) >= pItems->size()) {
      return nullptr;
    } else {
      return &(*pItems)[size_t(index)];
    }
  }
 
  template <typename T>
  static T* getSafe(std::vector<T>* pItems, int32_t index) noexcept {
    if (index < 0 || size_t(index) >= pItems->size()) {
      return nullptr;
    } else {
      return &(*pItems)[size_t(index)];
    }
  }
 
  void addExtensionUsed(const std::string& extensionName);
 
  void addExtensionRequired(const std::string& extensionName);
 
  void removeExtensionUsed(const std::string& extensionName);
 
  void removeExtensionRequired(const std::string& extensionName);
 
  bool isExtensionUsed(const std::string& extensionName) const noexcept;
 
  bool isExtensionRequired(const std::string& extensionName) const noexcept;
};
 
} // namespace CesiumGltf