PropertyAttributeView.h

#pragma once
 
#include "CesiumGltf/Class.h"
#include "CesiumGltf/ClassProperty.h"
#include "CesiumGltf/ExtensionModelExtStructuralMetadata.h"
#include "CesiumGltf/PropertyAttribute.h"
#include "CesiumGltf/PropertyAttributePropertyView.h"
#include "Model.h"
 
namespace CesiumGltf {
enum class PropertyAttributeViewStatus {
  Valid,
 
  ErrorMissingMetadataExtension,
 
  ErrorMissingSchema,
 
  ErrorClassNotFound
};
 
PropertyType getAccessorTypeAsPropertyType(const Accessor& accessor);
 
PropertyComponentType
getAccessorComponentTypeAsPropertyComponentType(const Accessor& accessor);
 
class PropertyAttributeView {
public:
  PropertyAttributeView(
      const Model& model,
      const PropertyAttribute& propertyAttribute) noexcept;
 
  PropertyAttributeViewStatus status() const noexcept { return this->_status; }
 
  const std::optional<std::string>& name() const noexcept {
    return _pPropertyAttribute->name;
  }
 
  const Class* getClass() const noexcept { return _pClass; }
 
  const ClassProperty* getClassProperty(const std::string& propertyId) const;
 
  template <typename T, bool Normalized = false>
  PropertyAttributePropertyView<T, Normalized> getPropertyView(
      const MeshPrimitive& primitive,
      const std::string& propertyId) const {
    if (this->_status != PropertyAttributeViewStatus::Valid) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorInvalidPropertyAttribute);
    }
    const ClassProperty* pClassProperty = getClassProperty(propertyId);
    if (!pClassProperty) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty);
    }
 
    if constexpr (
        IsMetadataArray<T>::value || IsMetadataBoolean<T>::value ||
        IsMetadataString<T>::value) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty);
    }
 
    return getPropertyViewImpl<T, Normalized>(
        primitive,
        propertyId,
        *pClassProperty);
  }
 
  template <typename Callback>
  void getPropertyView(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      Callback&& callback) const {
    if (this->_status != PropertyAttributeViewStatus::Valid) {
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::
                  ErrorInvalidPropertyAttribute));
      return;
    }
 
    const ClassProperty* pClassProperty = getClassProperty(propertyId);
    if (!pClassProperty) {
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorNonexistentProperty));
      return;
    }
 
    if (pClassProperty->array) {
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty));
      return;
    }
 
    PropertyType type = convertStringToPropertyType(pClassProperty->type);
    PropertyComponentType componentType = PropertyComponentType::None;
    if (pClassProperty->componentType) {
      componentType =
          convertStringToPropertyComponentType(*pClassProperty->componentType);
    }
 
    bool normalized = pClassProperty->normalized;
    if (normalized && !isPropertyComponentTypeInteger(componentType)) {
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorInvalidNormalization));
      return;
    }
 
    if (type == PropertyType::Scalar) {
      if (normalized) {
        getScalarPropertyViewImpl<Callback, true>(
            primitive,
            propertyId,
            *pClassProperty,
            componentType,
            std::forward<Callback>(callback));
      } else {
        getScalarPropertyViewImpl<Callback, false>(
            primitive,
            propertyId,
            *pClassProperty,
            componentType,
            std::forward<Callback>(callback));
      }
      return;
    }
 
    if (isPropertyTypeVecN(type)) {
      if (normalized) {
        getVecNPropertyViewImpl<Callback, true>(
            primitive,
            propertyId,
            *pClassProperty,
            type,
            componentType,
            std::forward<Callback>(callback));
      } else {
        getVecNPropertyViewImpl<Callback, false>(
            primitive,
            propertyId,
            *pClassProperty,
            type,
            componentType,
            std::forward<Callback>(callback));
      }
      return;
    }
 
    if (isPropertyTypeMatN(type)) {
      if (normalized) {
        getMatNPropertyViewImpl<Callback, true>(
            primitive,
            propertyId,
            *pClassProperty,
            type,
            componentType,
            std::forward<Callback>(callback));
      } else {
        getMatNPropertyViewImpl<Callback, false>(
            primitive,
            propertyId,
            *pClassProperty,
            type,
            componentType,
            std::forward<Callback>(callback));
      }
      return;
    }
 
    callback(
        propertyId,
        PropertyAttributePropertyView<uint8_t>(
            PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty));
    return;
  }
 
  template <typename Callback>
  void
  forEachProperty(const MeshPrimitive& primitive, Callback&& callback) const {
    for (const auto& property : this->_pClass->properties) {
      getPropertyView(
          primitive,
          property.first,
          std::forward<Callback>(callback));
    }
  }
 
private:
  template <typename T, bool Normalized>
  PropertyAttributePropertyView<T, Normalized> getEmptyPropertyViewWithDefault(
      const MeshPrimitive& primitive,
      const ClassProperty& classProperty) const {
    // To make the view have a nonzero size, find the POSITION attribute and get
    // its accessor count. If it doesn't exist or is somehow erroneous, just
    // mark the property as nonexistent.
    if (primitive.attributes.find("POSITION") == primitive.attributes.end()) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty);
    }
 
    const Accessor* pAccessor = _pModel->getSafe<Accessor>(
        &_pModel->accessors,
        primitive.attributes.at("POSITION"));
    if (!pAccessor) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty);
    }
 
    return PropertyAttributePropertyView<T, Normalized>(
        classProperty,
        pAccessor->count);
  }
 
  template <typename T, bool Normalized>
  PropertyAttributePropertyView<T, Normalized> getPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty) const {
    auto propertyAttributePropertyIter =
        _pPropertyAttribute->properties.find(propertyId);
    if (propertyAttributePropertyIter ==
        _pPropertyAttribute->properties.end()) {
      if (!classProperty.required && classProperty.defaultProperty) {
        // If the property was omitted from the property attribute, it is still
        // technically valid if it specifies a default value. Try to create a
        // view that just returns the default value.
        return getEmptyPropertyViewWithDefault<T, Normalized>(
            primitive,
            classProperty);
      }
 
      // Otherwise, the property is erroneously nonexistent.
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty);
    }
 
    const PropertyAttributeProperty& propertyAttributeProperty =
        propertyAttributePropertyIter->second;
 
    return createPropertyView<T, Normalized>(
        primitive,
        classProperty,
        propertyAttributeProperty);
  }
 
  template <typename Callback, bool Normalized>
  void getScalarPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty,
      PropertyComponentType componentType,
      Callback&& callback) const {
    switch (componentType) {
    case PropertyComponentType::Int8:
      callback(
          propertyId,
          getPropertyViewImpl<int8_t, Normalized>(
              primitive,
              propertyId,
              classProperty));
      return;
    case PropertyComponentType::Uint8:
      callback(
          propertyId,
          getPropertyViewImpl<uint8_t, Normalized>(
              primitive,
              propertyId,
              classProperty));
      return;
    case PropertyComponentType::Int16:
      callback(
          propertyId,
          getPropertyViewImpl<int16_t, Normalized>(
              primitive,
              propertyId,
              classProperty));
      return;
    case PropertyComponentType::Uint16:
      callback(
          propertyId,
          getPropertyViewImpl<uint16_t, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Float32:
      callback(
          propertyId,
          getPropertyViewImpl<float, false>(
              primitive,
              propertyId,
              classProperty));
      break;
    default:
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty));
      break;
    }
  }
 
  template <typename Callback, glm::length_t N, bool Normalized>
  void getVecNPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty,
      PropertyComponentType componentType,
      Callback&& callback) const {
    switch (componentType) {
    case PropertyComponentType::Int8:
      callback(
          propertyId,
          getPropertyViewImpl<glm::vec<N, int8_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Uint8:
      callback(
          propertyId,
          getPropertyViewImpl<glm::vec<N, uint8_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Int16:
      callback(
          propertyId,
          getPropertyViewImpl<glm::vec<N, int16_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Uint16:
      callback(
          propertyId,
          getPropertyViewImpl<glm::vec<N, uint16_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Float32:
      callback(
          propertyId,
          getPropertyViewImpl<glm::vec<N, float>, false>(
              primitive,
              propertyId,
              classProperty));
      break;
    default:
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty));
      break;
    }
  }
 
  template <typename Callback, bool Normalized>
  void getVecNPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty,
      PropertyType type,
      PropertyComponentType componentType,
      Callback&& callback) const {
    const glm::length_t N = getDimensionsFromPropertyType(type);
    switch (N) {
    case 2:
      getVecNPropertyViewImpl<Callback, 2, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    case 3:
      getVecNPropertyViewImpl<Callback, 3, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    case 4:
      getVecNPropertyViewImpl<Callback, 4, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    default:
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorTypeMismatch));
      break;
    }
  }
 
  template <typename Callback, glm::length_t N, bool Normalized>
  void getMatNPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty,
      PropertyComponentType componentType,
      Callback&& callback) const {
    switch (componentType) {
    case PropertyComponentType::Int8:
      callback(
          propertyId,
          getPropertyViewImpl<glm::mat<N, N, int8_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Uint8:
      callback(
          propertyId,
          getPropertyViewImpl<glm::mat<N, N, uint8_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Int16:
      callback(
          propertyId,
          getPropertyViewImpl<glm::mat<N, N, int16_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Uint16:
      callback(
          propertyId,
          getPropertyViewImpl<glm::mat<N, N, uint16_t>, Normalized>(
              primitive,
              propertyId,
              classProperty));
      break;
    case PropertyComponentType::Float32:
      callback(
          propertyId,
          getPropertyViewImpl<glm::mat<N, N, float>, false>(
              primitive,
              propertyId,
              classProperty));
      break;
    default:
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorUnsupportedProperty));
      break;
    }
  }
 
  template <typename Callback, bool Normalized>
  void getMatNPropertyViewImpl(
      const MeshPrimitive& primitive,
      const std::string& propertyId,
      const ClassProperty& classProperty,
      PropertyType type,
      PropertyComponentType componentType,
      Callback&& callback) const {
    glm::length_t N = getDimensionsFromPropertyType(type);
    switch (N) {
    case 2:
      getMatNPropertyViewImpl<Callback, 2, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    case 3:
      getMatNPropertyViewImpl<Callback, 3, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    case 4:
      getMatNPropertyViewImpl<Callback, 4, Normalized>(
          primitive,
          propertyId,
          classProperty,
          componentType,
          std::forward<Callback>(callback));
      break;
    default:
      callback(
          propertyId,
          PropertyAttributePropertyView<uint8_t>(
              PropertyAttributePropertyViewStatus::ErrorTypeMismatch));
      break;
    }
  }
 
  template <typename T, bool Normalized>
  PropertyAttributePropertyView<T, Normalized> createPropertyView(
      const MeshPrimitive& primitive,
      const ClassProperty& classProperty,
      const PropertyAttributeProperty& propertyAttributeProperty) const {
    const PropertyType type = convertStringToPropertyType(classProperty.type);
    if (TypeToPropertyType<T>::value != type) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorTypeMismatch);
    }
 
    const PropertyComponentType componentType =
        convertStringToPropertyComponentType(
            classProperty.componentType.value_or(""));
    if (TypeToPropertyType<T>::component != componentType) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorComponentTypeMismatch);
    }
 
    if (classProperty.normalized != Normalized) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorNormalizationMismatch);
    }
 
    if (primitive.attributes.find(propertyAttributeProperty.attribute) ==
        primitive.attributes.end()) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorMissingAttribute);
    }
 
    const Accessor* pAccessor = _pModel->getSafe<Accessor>(
        &_pModel->accessors,
        primitive.attributes.at(propertyAttributeProperty.attribute));
    if (!pAccessor) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorInvalidAccessor);
    }
 
    if (getAccessorTypeAsPropertyType(*pAccessor) != type) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::ErrorAccessorTypeMismatch);
    }
 
    if (getAccessorComponentTypeAsPropertyComponentType(*pAccessor) !=
        componentType) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::
              ErrorAccessorComponentTypeMismatch);
    }
 
    if (pAccessor->normalized != Normalized) {
      return PropertyAttributePropertyView<T, Normalized>(
          PropertyAttributePropertyViewStatus::
              ErrorAccessorNormalizationMismatch);
    }
 
    AccessorView<T> accessorView = AccessorView<T>(*_pModel, *pAccessor);
    if (accessorView.status() != AccessorViewStatus::Valid) {
      switch (accessorView.status()) {
      case AccessorViewStatus::InvalidBufferViewIndex:
        return PropertyAttributePropertyView<T, Normalized>(
            PropertyAttributePropertyViewStatus::ErrorInvalidBufferView);
      case AccessorViewStatus::InvalidBufferIndex:
        return PropertyAttributePropertyView<T, Normalized>(
            PropertyAttributePropertyViewStatus::ErrorInvalidBuffer);
      case AccessorViewStatus::BufferViewTooSmall:
        return PropertyAttributePropertyView<T, Normalized>(
            PropertyAttributePropertyViewStatus::ErrorAccessorOutOfBounds);
      case AccessorViewStatus::BufferTooSmall:
        return PropertyAttributePropertyView<T, Normalized>(
            PropertyAttributePropertyViewStatus::ErrorBufferViewOutOfBounds);
      default:
        return PropertyAttributePropertyView<T, Normalized>(
            PropertyAttributePropertyViewStatus::ErrorInvalidAccessor);
      }
    }
 
    return PropertyAttributePropertyView<T, Normalized>(
        propertyAttributeProperty,
        classProperty,
        accessorView);
  }
 
  const Model* _pModel;
  const PropertyAttribute* _pPropertyAttribute;
  const Class* _pClass;
 
  PropertyAttributeViewStatus _status;
};
 
} // namespace CesiumGltf