AccessorUtility.h

#pragma once
 
#include <CesiumGltf/AccessorView.h>
#include <CesiumGltf/MeshPrimitive.h>
 
#include <glm/common.hpp>
#include <glm/ext/quaternion_double.hpp>
 
#include <array>
#include <type_traits>
#include <variant>
 
namespace CesiumGltf {
 
namespace CesiumImpl {
template <typename T> double denormalize(T value) {
  if constexpr (std::is_floating_point_v<T>) {
    return double(value);
  } else if constexpr (std::is_signed_v<T>) {
    return glm::max(double(value) / std::numeric_limits<T>::max(), -1.0);
  } else {
    return double(value) / std::numeric_limits<T>::max();
  }
}
} // namespace CesiumImpl

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 std::variant<
    AccessorView<AccessorTypes::VEC3<int8_t>>,
    AccessorView<AccessorTypes::VEC3<uint8_t>>,
    AccessorView<AccessorTypes::VEC3<int16_t>>,
    AccessorView<AccessorTypes::VEC3<uint16_t>>,
    AccessorView<AccessorTypes::VEC3<float>>>
    PositionAccessorType;

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

struct PositionFromAccessor {
  template <typename T>
  std::optional<glm::dvec3>
  operator()(const AccessorView<AccessorTypes::VEC3<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    if (value.normalized()) {
      return glm::dvec3(
          CesiumImpl::denormalize(value[index].value[0]),
          CesiumImpl::denormalize(value[index].value[1]),
          CesiumImpl::denormalize(value[index].value[2]));
    } else {
      return glm::dvec3(
          value[index].value[0],
          value[index].value[1],
          value[index].value[2]);
    }
  }

  int64_t index;
};

typedef std::variant<
    AccessorView<AccessorTypes::VEC3<int8_t>>,
    AccessorView<AccessorTypes::VEC3<int16_t>>,
    AccessorView<AccessorTypes::VEC3<float>>>
    NormalAccessorType;

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

struct NormalFromAccessor {
  template <typename T>
  std::optional<glm::dvec3>
  operator()(const AccessorView<AccessorTypes::VEC3<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    if (value.normalized()) {
      return glm::dvec3(
          CesiumImpl::denormalize(value[index].value[0]),
          CesiumImpl::denormalize(value[index].value[1]),
          CesiumImpl::denormalize(value[index].value[2]));
    } else {
      return glm::dvec3(
          value[index].value[0],
          value[index].value[1],
          value[index].value[2]);
    }
  }

  int64_t index;
};

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 featureIdSetIndex);

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

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);

IndexAccessorType
getIndexAccessorView(const Model& model, const Accessor& accessor);

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<int8_t>>,
    AccessorView<AccessorTypes::VEC2<uint8_t>>,
    AccessorView<AccessorTypes::VEC2<int16_t>>,
    AccessorView<AccessorTypes::VEC2<uint16_t>>,
    AccessorView<AccessorTypes::VEC2<float>>>
    TexCoordAccessorType;

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

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

  int64_t index;
};

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

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

QuaternionAccessorType
getQuaternionAccessorView(const Model& model, int32_t accessorIndex);

struct QuaternionFromAccessor {
  template <typename T>
  std::optional<glm::dquat>
  operator()(const AccessorView<AccessorTypes::VEC4<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    if (value.normalized()) {
      // glm quat constructor is w,x,y,z
      return glm::dquat(
          CesiumImpl::denormalize(value[index].value[3]),
          CesiumImpl::denormalize(value[index].value[0]),
          CesiumImpl::denormalize(value[index].value[1]),
          CesiumImpl::denormalize(value[index].value[2]));
    } else {
      // glm quat constructor is w,x,y,z
      return glm::dquat(
          value[index].value[3],
          value[index].value[0],
          value[index].value[1],
          value[index].value[2]);
    }
  }

  int64_t index;
};

typedef std::variant<
    AccessorView<AccessorTypes::VEC3<uint8_t>>,
    AccessorView<AccessorTypes::VEC3<uint16_t>>,
    AccessorView<AccessorTypes::VEC3<float>>,
    AccessorView<AccessorTypes::VEC4<uint8_t>>,
    AccessorView<AccessorTypes::VEC4<uint16_t>>,
    AccessorView<AccessorTypes::VEC4<float>>>
    ColorAccessorType;

ColorAccessorType getColorAccessorView(
    const Model& model,
    const MeshPrimitive& primitive,
    int32_t colorSetIndex);

struct ColorFromAccessor {
  template <typename T>
  std::optional<glm::dvec4>
  operator()(const AccessorView<AccessorTypes::VEC3<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    if (value.normalized()) {
      return glm::dvec4(
          CesiumImpl::denormalize(value[index].value[0]),
          CesiumImpl::denormalize(value[index].value[1]),
          CesiumImpl::denormalize(value[index].value[2]),
          1.0);
    } else {
      return glm::dvec4(
          value[index].value[0],
          value[index].value[1],
          value[index].value[2],
          1.0);
    }
  }

  template <typename T>
  std::optional<glm::dvec4>
  operator()(const AccessorView<AccessorTypes::VEC4<T>>& value) {
    if (index < 0 || index >= value.size()) {
      return std::nullopt;
    }
 
    if (value.normalized()) {
      return glm::dvec4(
          CesiumImpl::denormalize(value[index].value[0]),
          CesiumImpl::denormalize(value[index].value[1]),
          CesiumImpl::denormalize(value[index].value[2]),
          CesiumImpl::denormalize(value[index].value[3]));
    } else {
      return glm::dvec4(
          value[index].value[0],
          value[index].value[1],
          value[index].value[2],
          value[index].value[3]);
    }
  }

  int64_t index;
};
 
} // namespace CesiumGltf