PropertyAttributePropertyView.h

#pragma once
 
#include <CesiumGltf/AccessorView.h>
#include <CesiumGltf/PropertyAttributeProperty.h>
#include <CesiumGltf/PropertyTransformations.h>
#include <CesiumGltf/PropertyTypeTraits.h>
#include <CesiumGltf/PropertyView.h>
#include <CesiumUtility/Assert.h>
 
#include <cmath>
#include <cstdint>
 
namespace CesiumGltf {
class PropertyAttributePropertyViewStatus : public PropertyViewStatus {
public:
  static const int ErrorInvalidPropertyAttribute = 15;

  static const int ErrorUnsupportedProperty = 16;

  static const int ErrorMissingAttribute = 17;

  static const int ErrorInvalidAccessor = 18;

  static const int ErrorAccessorTypeMismatch = 19;

  static const int ErrorAccessorComponentTypeMismatch = 20;

  static const int ErrorAccessorNormalizationMismatch = 21;

  static const int ErrorInvalidBufferView = 22;

  static const int ErrorInvalidBuffer = 23;

  static const PropertyViewStatusType ErrorAccessorOutOfBounds = 24;

  static const PropertyViewStatusType ErrorBufferViewOutOfBounds = 25;
};

template <typename ElementType, bool Normalized = false>
class PropertyAttributePropertyView;

template <typename ElementType>
class PropertyAttributePropertyView<ElementType, false>
    : public PropertyView<ElementType, false> {
public:
  PropertyAttributePropertyView() noexcept
      : PropertyView<ElementType, false>(), _accessor{}, _size{0} {}

  PropertyAttributePropertyView(PropertyViewStatusType status) noexcept
      : PropertyView<ElementType, false>(status), _accessor{}, _size{0} {
    CESIUM_ASSERT(
        this->_status != PropertyAttributePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid status");
  }

  PropertyAttributePropertyView(
      const ClassProperty& classProperty,
      int64_t size) noexcept
      : PropertyView<ElementType, false>(classProperty), _accessor{}, _size{0} {
    if (this->_status != PropertyAttributePropertyViewStatus::Valid) {
      // Don't override the status / size if something is wrong with the class
      // property's definition.
      return;
    }
 
    if (!classProperty.defaultProperty) {
      // This constructor should only be called if the class property *has* a
      // default value. But in the case that it does not, this property view
      // becomes invalid.
      this->_status =
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status =
        PropertyAttributePropertyViewStatus::EmptyPropertyWithDefault;
    this->_size = size;
  }

  PropertyAttributePropertyView(
      const PropertyAttributeProperty& property,
      const ClassProperty& classProperty,
      const AccessorView<ElementType>& accessorView) noexcept
      : PropertyView<ElementType, false>(classProperty, property),
        _accessor{accessorView},
        _size{
            this->_status == PropertyAttributePropertyViewStatus::Valid
                ? accessorView.size()
                : 0} {}

  std::optional<ElementType> get(int64_t index) const noexcept {
    if (this->_status ==
        PropertyAttributePropertyViewStatus::EmptyPropertyWithDefault) {
      return this->defaultValue();
    }
 
    ElementType value = getRaw(index);
 
    if (value == this->noData()) {
      return this->defaultValue();
    }
 
    return transformValue(value, this->offset(), this->scale());
  }

  ElementType getRaw(int64_t index) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyAttributePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
    CESIUM_ASSERT(
        size() > 0 &&
        "Check the size() of the view to make sure it's not empty");
    CESIUM_ASSERT(index >= 0 && "index must be non-negative");
    CESIUM_ASSERT(index < size() && "index must be less than size");
 
    return _accessor[index];
  }

  int64_t size() const noexcept { return _size; }

  const AccessorView<ElementType>& accessorView() const { return _accessor; }
 
private:
  AccessorView<ElementType> _accessor;
  int64_t _size;
};

template <typename ElementType>
class PropertyAttributePropertyView<ElementType, true>
    : public PropertyView<ElementType, true> {
private:
  using NormalizedType = typename TypeToNormalizedType<ElementType>::type;
 
public:
  PropertyAttributePropertyView() noexcept
      : PropertyView<ElementType, true>(), _accessor{}, _size{0} {}

  PropertyAttributePropertyView(PropertyViewStatusType status) noexcept
      : PropertyView<ElementType, true>(status), _accessor{}, _size{0} {
    CESIUM_ASSERT(
        this->_status != PropertyAttributePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid status");
  }

  PropertyAttributePropertyView(
      const ClassProperty& classProperty,
      int64_t size) noexcept
      : PropertyView<ElementType, true>(classProperty), _accessor{}, _size{0} {
    if (this->_status != PropertyAttributePropertyViewStatus::Valid) {
      // Don't override the status / size if something is wrong with the class
      // property's definition.
      return;
    }
 
    if (!classProperty.defaultProperty) {
      // This constructor should only be called if the class property *has* a
      // default value. But in the case that it does not, this property view
      // becomes invalid.
      this->_status =
          PropertyAttributePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status =
        PropertyAttributePropertyViewStatus::EmptyPropertyWithDefault;
    this->_size = size;
  }

  PropertyAttributePropertyView(
      const PropertyAttributeProperty& property,
      const ClassProperty& classProperty,
      const AccessorView<ElementType>& accessorView) noexcept
      : PropertyView<ElementType, true>(classProperty, property),
        _accessor{accessorView},
        _size{
            this->_status == PropertyAttributePropertyViewStatus::Valid
                ? accessorView.size()
                : 0} {}

  std::optional<NormalizedType> get(int64_t index) const noexcept {
    if (this->_status ==
        PropertyAttributePropertyViewStatus::EmptyPropertyWithDefault) {
      return this->defaultValue();
    }
 
    ElementType value = getRaw(index);
 
    if (value == this->noData()) {
      return this->defaultValue();
    }
 
    if constexpr (IsMetadataScalar<ElementType>::value) {
      return transformValue<NormalizedType>(
          normalize<ElementType>(value),
          this->offset(),
          this->scale());
    }
 
    if constexpr (IsMetadataVecN<ElementType>::value) {
      constexpr glm::length_t N = ElementType::length();
      using T = typename ElementType::value_type;
      using NormalizedT = typename NormalizedType::value_type;
      return transformValue<glm::vec<N, NormalizedT>>(
          normalize<N, T>(value),
          this->offset(),
          this->scale());
    }
 
    if constexpr (IsMetadataMatN<ElementType>::value) {
      constexpr glm::length_t N = ElementType::length();
      using T = typename ElementType::value_type;
      using NormalizedT = typename NormalizedType::value_type;
      return transformValue<glm::mat<N, N, NormalizedT>>(
          normalize<N, T>(value),
          this->offset(),
          this->scale());
    }
  }

  ElementType getRaw(int64_t index) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyAttributePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
    CESIUM_ASSERT(
        size() > 0 &&
        "Check the size() of the view to make sure it's not empty");
    CESIUM_ASSERT(index >= 0 && "index must be non-negative");
    CESIUM_ASSERT(index < size() && "index must be less than size");
 
    return _accessor[index];
  }

  int64_t size() const noexcept { return _size; }

  const AccessorView<ElementType>& accessorView() const { return _accessor; }
 
private:
  AccessorView<ElementType> _accessor;
  int64_t _size;
};
 
} // namespace CesiumGltf