AccessorUtility.h

#pragma once
 
#include <CesiumGltf/AccessorView.h>
#include <CesiumGltf/MeshPrimitive.h>
 
#include <glm/common.hpp>
 
#include <array>
#include <variant>
 
namespace CesiumGltf {
struct CountFromAccessor {
  int64_t operator()(std::monostate) { return 0; }

  template <typename T> int64_t operator()(const AccessorView<T>& value) {
    return value.size();
  }
};

struct StatusFromAccessor {
  AccessorViewStatus operator()(std::monostate) {
    return AccessorViewStatus::InvalidAccessorIndex;
  }

  template <typename T>
  AccessorViewStatus operator()(const AccessorView<T>& value) {
    return value.status();
  }
};

typedef AccessorView<AccessorTypes::VEC3<float>> PositionAccessorType;

PositionAccessorType
getPositionAccessorView(const Model& model, const MeshPrimitive& primitive);

typedef AccessorView<AccessorTypes::VEC3<float>> NormalAccessorType;

NormalAccessorType
getNormalAccessorView(const Model& model, const MeshPrimitive& primitive);

typedef std::variant<
    AccessorView<int8_t>,
    AccessorView<uint8_t>,
    AccessorView<int16_t>,
    AccessorView<uint16_t>,
    AccessorView<uint32_t>,
    AccessorView<float>>
    FeatureIdAccessorType;

FeatureIdAccessorType getFeatureIdAccessorView(
    const Model& model,
    const MeshPrimitive& primitive,
    int32_t featureIdAttributeIndex);

FeatureIdAccessorType getFeatureIdAccessorView(
    const Model& model,
    const Node& node,
    int32_t featureIdAttributeIndex);

struct FeatureIdFromAccessor {
  int64_t operator()(const AccessorView<float>& value) {
    if (index < 0 || index >= value.size()) {
      return -1;
    }
    return static_cast<int64_t>(glm::round(value[index]));
  }

  template <typename T> int64_t operator()(const AccessorView<T>& value) {
    if (index < 0 || index >= value.size()) {
      return -1;
    }
    return static_cast<int64_t>(value[index]);
  }

  int64_t index;
};

typedef std::variant<
    std::monostate,
    AccessorView<uint8_t>,
    AccessorView<uint16_t>,
    AccessorView<uint32_t>>
    IndexAccessorType;

IndexAccessorType
getIndexAccessorView(const Model& model, const MeshPrimitive& primitive);

IndexAccessorType getIndexAccessorView(const Model& model, int32_t index);

struct NumIndicesFromAccessor {
  int64_t operator()(std::monostate) { return 0; }

  template <typename T> int64_t operator()(const AccessorView<T>& value) {
    return value.size();
  }
};

struct MaxIndexValueFromAccessor {
  int64_t operator()(std::monostate) { return -1; }

  template <typename T> int64_t operator()(const AccessorView<T>& /*value*/) {
    return static_cast<int64_t>(std::numeric_limits<T>::max());
  }
};

struct IndicesForFaceFromAccessor {
  std::array<int64_t, 3> operator()(std::monostate) {
    int64_t firstVertex = faceIndex;
    int64_t numFaces = 0;
 
    switch (primitiveMode) {
    case MeshPrimitive::Mode::TRIANGLE_STRIP:
      numFaces = vertexCount - 2;
      break;
    case MeshPrimitive::Mode::TRIANGLE_FAN:
      numFaces = vertexCount - 2;
      firstVertex++;
      break;
    case MeshPrimitive::Mode::TRIANGLES:
      numFaces = vertexCount / 3;
      firstVertex *= 3;
      break;
    default:
      // Unsupported primitive mode.
      return {-1, -1, -1};
    }
 
    if (faceIndex < 0 || faceIndex >= numFaces) {
      return {-1, -1, -1};
    }
 
    std::array<int64_t, 3> result;
 
    if (primitiveMode == MeshPrimitive::Mode::TRIANGLE_FAN) {
      result[0] = 0;
      result[1] = firstVertex < vertexCount ? firstVertex : -1;
      result[2] = firstVertex + 1 < vertexCount ? firstVertex + 1 : -1;
    } else {
      for (int64_t i = 0; i < 3; i++) {
        int64_t vertexIndex = firstVertex + i;
        result[static_cast<size_t>(i)] =
            vertexIndex < vertexCount ? vertexIndex : -1;
      }
    }
 
    return result;
  }

  template <typename T>
  std::array<int64_t, 3> operator()(const AccessorView<T>& value) {
    int64_t firstIndex = faceIndex;
    int64_t numFaces = 0;
 
    switch (primitiveMode) {
    case MeshPrimitive::Mode::TRIANGLE_STRIP:
      numFaces = value.size() - 2;
      break;
    case MeshPrimitive::Mode::TRIANGLE_FAN:
      numFaces = value.size() - 2;
      firstIndex++;
      break;
    case MeshPrimitive::Mode::TRIANGLES:
      numFaces = value.size() / 3;
      firstIndex *= 3;
      break;
    default:
      // Unsupported primitive mode.
      return {-1, -1, -1};
    }
 
    if (faceIndex < 0 || faceIndex >= numFaces) {
      return {-1, -1, -1};
    }
 
    std::array<int64_t, 3> result;
 
    if (primitiveMode == MeshPrimitive::Mode::TRIANGLE_FAN) {
      result[0] = value[0];
      result[1] = firstIndex < value.size()
                      ? static_cast<int64_t>(value[firstIndex])
                      : -1;
      result[2] = firstIndex + 1 < value.size()
                      ? static_cast<int64_t>(value[firstIndex + 1])
                      : -1;
    } else {
      for (int64_t i = 0; i < 3; i++) {
        int64_t index = firstIndex + i;
        result[static_cast<size_t>(i)] =
            index < value.size() ? static_cast<int64_t>(value[index]) : -1;
      }
    }
 
    return result;
  }

  int64_t faceIndex;
  int64_t vertexCount;
  int32_t primitiveMode;
}; // namespace CesiumGltf

struct IndexFromAccessor {
  int64_t operator()(std::monostate) { return -1; }

  template <typename T>
  int64_t operator()(const CesiumGltf::AccessorView<T>& value) {
    if (index < 0 || index >= value.size()) {
      return -1;
    }
 
    return value[index];
  }

  int64_t index;
};

typedef std::variant<
    AccessorView<AccessorTypes::VEC2<uint8_t>>,
    AccessorView<AccessorTypes::VEC2<uint16_t>>,
    AccessorView<AccessorTypes::VEC2<float>>>
    TexCoordAccessorType;

TexCoordAccessorType getTexCoordAccessorView(
    const Model& model,
    const MeshPrimitive& primitive,
    int32_t textureCoordinateSetIndex);

struct TexCoordFromAccessor {
  std::optional<glm::dvec2>
  operator()(const AccessorView<AccessorTypes::VEC2<float>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    return glm::dvec2(value[index].value[0], value[index].value[1]);
  }

  template <typename T>
  std::optional<glm::dvec2>
  operator()(const AccessorView<AccessorTypes::VEC2<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    double u = static_cast<double>(value[index].value[0]);
    double v = static_cast<double>(value[index].value[1]);
 
    // TODO: do normalization logic in accessor view?
    u /= std::numeric_limits<T>::max();
    v /= std::numeric_limits<T>::max();
 
    return glm::dvec2(u, v);
  }

  int64_t index;
};

typedef std::variant<
    AccessorView<AccessorTypes::VEC4<uint8_t>>,
    AccessorView<AccessorTypes::VEC4<int8_t>>,
    AccessorView<AccessorTypes::VEC4<uint16_t>>,
    AccessorView<AccessorTypes::VEC4<int16_t>>,
    AccessorView<AccessorTypes::VEC4<float>>>
    QuaternionAccessorType;

QuaternionAccessorType
getQuaternionAccessorView(const Model& model, const Accessor* accessor);

QuaternionAccessorType
getQuaternionAccessorView(const Model& model, int32_t accessorIndex);
} // namespace CesiumGltf