PropertyTexturePropertyView.h

#pragma once
 
#include <CesiumGltf/ImageAsset.h>
#include <CesiumGltf/KhrTextureTransform.h>
#include <CesiumGltf/PropertyTextureProperty.h>
#include <CesiumGltf/PropertyTransformations.h>
#include <CesiumGltf/PropertyTypeTraits.h>
#include <CesiumGltf/PropertyView.h>
#include <CesiumGltf/Sampler.h>
#include <CesiumGltf/TextureView.h>
#include <CesiumUtility/Assert.h>
 
#include <array>
#include <cmath>
#include <cstdint>
#include <optional>
 
namespace CesiumGltf {
class PropertyTexturePropertyViewStatus : public PropertyViewStatus {
public:
  static const int ErrorInvalidPropertyTexture = 14;
 
  static const int ErrorUnsupportedProperty = 15;
 
  static const int ErrorInvalidTexture = 16;
 
  static const int ErrorInvalidSampler = 17;
 
  static const int ErrorInvalidImage = 18;
 
  static const int ErrorEmptyImage = 19;
 
  static const int ErrorInvalidBytesPerChannel = 20;
 
  static const int ErrorInvalidChannels = 21;
 
  static const int ErrorChannelsAndTypeMismatch = 22;
};
 
template <typename ElementType>
ElementType assembleScalarValue(const std::span<uint8_t> bytes) noexcept {
  if constexpr (std::is_same_v<ElementType, float>) {
    CESIUM_ASSERT(
        bytes.size() == sizeof(float) &&
        "Not enough channel inputs to construct a float.");
    uint32_t resultAsUint = 0;
    for (size_t i = 0; i < bytes.size(); i++) {
      resultAsUint |= static_cast<uint32_t>(bytes[i]) << i * 8;
    }
 
    // Reinterpret the bits as a float.
    return *reinterpret_cast<float*>(&resultAsUint);
  }
 
  if constexpr (IsMetadataInteger<ElementType>::value) {
    using UintType = std::make_unsigned_t<ElementType>;
    UintType resultAsUint = 0;
    for (size_t i = 0; i < bytes.size(); i++) {
      resultAsUint |= static_cast<UintType>(bytes[i]) << i * 8;
    }
 
    // Reinterpret the bits with the correct signedness.
    return *reinterpret_cast<ElementType*>(&resultAsUint);
  }
}
 
template <typename ElementType>
ElementType assembleVecNValue(const std::span<uint8_t> bytes) noexcept {
  ElementType result = ElementType();
 
  const glm::length_t N =
      getDimensionsFromPropertyType(TypeToPropertyType<ElementType>::value);
  using T = typename ElementType::value_type;
 
  CESIUM_ASSERT(
      sizeof(T) <= 2 && "Components cannot be larger than two bytes in size.");
 
  if constexpr (std::is_same_v<T, int16_t>) {
    CESIUM_ASSERT(
        N == 2 && "Only vec2s can contain two-byte integer components.");
    uint16_t x = static_cast<uint16_t>(bytes[0]) |
                 (static_cast<uint16_t>(bytes[1]) << 8);
    uint16_t y = static_cast<uint16_t>(bytes[2]) |
                 (static_cast<uint16_t>(bytes[3]) << 8);
 
    result[0] = *reinterpret_cast<int16_t*>(&x);
    result[1] = *reinterpret_cast<int16_t*>(&y);
  }
 
  if constexpr (std::is_same_v<T, uint16_t>) {
    CESIUM_ASSERT(
        N == 2 && "Only vec2s can contain two-byte integer components.");
    result[0] = static_cast<uint16_t>(bytes[0]) |
                (static_cast<uint16_t>(bytes[1]) << 8);
    result[1] = static_cast<uint16_t>(bytes[2]) |
                (static_cast<uint16_t>(bytes[3]) << 8);
  }
 
  if constexpr (std::is_same_v<T, int8_t>) {
    for (size_t i = 0; i < bytes.size(); i++) {
      result[i] = *reinterpret_cast<const int8_t*>(&bytes[i]);
    }
  }
 
  if constexpr (std::is_same_v<T, uint8_t>) {
    for (size_t i = 0; i < bytes.size(); i++) {
      result[i] = bytes[i];
    }
  }
 
  return result;
}
 
template <typename T>
PropertyArrayCopy<T>
assembleArrayValue(const std::span<uint8_t> bytes) noexcept {
  std::vector<T> result(bytes.size() / sizeof(T));
 
  if constexpr (sizeof(T) == 2) {
    for (int i = 0, b = 0; i < result.size(); i++, b += 2) {
      using UintType = std::make_unsigned_t<T>;
      UintType resultAsUint = static_cast<UintType>(bytes[b]) |
                              (static_cast<UintType>(bytes[b + 1]) << 8);
      result[i] = *reinterpret_cast<T*>(&resultAsUint);
    }
  } else {
    for (size_t i = 0; i < bytes.size(); i++) {
      result[i] = *reinterpret_cast<const T*>(&bytes[i]);
    }
  }
 
  return PropertyArrayCopy<T>(std::move(result));
}
 
template <typename ElementType>
PropertyValueViewToCopy<ElementType>
assembleValueFromChannels(const std::span<uint8_t> bytes) noexcept {
  CESIUM_ASSERT(
      bytes.size() > 0 && "Channel input must have at least one value.");
 
  if constexpr (IsMetadataScalar<ElementType>::value) {
    return assembleScalarValue<ElementType>(bytes);
  }
 
  if constexpr (IsMetadataVecN<ElementType>::value) {
    return assembleVecNValue<ElementType>(bytes);
  }
 
  if constexpr (IsMetadataArray<ElementType>::value) {
    return assembleArrayValue<typename MetadataArrayType<ElementType>::type>(
        bytes);
  }
}
 
#pragma region Non - normalized property
 
template <typename ElementType, bool Normalized = false>
class PropertyTexturePropertyView;
 
template <typename ElementType>
class PropertyTexturePropertyView<ElementType, false>
    : public PropertyView<ElementType, false>, public TextureView {
public:
  PropertyTexturePropertyView() noexcept
      : PropertyView<ElementType, false>(),
        TextureView(),
        _channels(),
        _swizzle() {}
 
  PropertyTexturePropertyView(PropertyViewStatusType status) noexcept
      : PropertyView<ElementType, false>(status),
        TextureView(),
        _channels(),
        _swizzle() {
    CESIUM_ASSERT(
        this->_status != PropertyTexturePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid status");
  }
 
  PropertyTexturePropertyView(const ClassProperty& classProperty) noexcept
      : PropertyView<ElementType, false>(classProperty),
        TextureView(),
        _channels(),
        _swizzle() {
    if (this->_status != PropertyTexturePropertyViewStatus::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 =
          PropertyTexturePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status = PropertyTexturePropertyViewStatus::EmptyPropertyWithDefault;
  }
 
  PropertyTexturePropertyView(
      const PropertyTextureProperty& property,
      const ClassProperty& classProperty,
      const Sampler& sampler,
      const ImageAsset& image,
      const TextureViewOptions& options = TextureViewOptions()) noexcept
      : PropertyView<ElementType, false>(classProperty, property),
        TextureView(
            sampler,
            image,
            property.texCoord,
            property.getExtension<ExtensionKhrTextureTransform>(),
            options),
        _channels(property.channels),
        _swizzle() {
    if (this->_status != PropertyTexturePropertyViewStatus::Valid) {
      return;
    }
 
    switch (this->getTextureViewStatus()) {
    case TextureViewStatus::Valid:
      break;
    case TextureViewStatus::ErrorInvalidSampler:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidSampler;
      return;
    case TextureViewStatus::ErrorInvalidImage:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidImage;
      return;
    case TextureViewStatus::ErrorEmptyImage:
      this->_status = PropertyTexturePropertyViewStatus::ErrorEmptyImage;
      return;
    case TextureViewStatus::ErrorInvalidBytesPerChannel:
      this->_status =
          PropertyTexturePropertyViewStatus::ErrorInvalidBytesPerChannel;
      return;
    case TextureViewStatus::ErrorUninitialized:
    case TextureViewStatus::ErrorInvalidTexture:
    default:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidTexture;
      return;
    }
 
    _swizzle.reserve(_channels.size());
 
    for (size_t i = 0; i < _channels.size(); ++i) {
      switch (_channels[i]) {
      case 0:
        _swizzle += "r";
        break;
      case 1:
        _swizzle += "g";
        break;
      case 2:
        _swizzle += "b";
        break;
      case 3:
        _swizzle += "a";
        break;
      default:
        CESIUM_ASSERT(
            false && "A valid channels vector must be passed to the view.");
      }
    }
  }
 
  std::optional<PropertyValueViewToCopy<ElementType>>
  get(double u, double v) const noexcept {
    if (this->_status ==
        PropertyTexturePropertyViewStatus::EmptyPropertyWithDefault) {
      return propertyValueViewToCopy(this->defaultValue());
    }
 
    PropertyValueViewToCopy<ElementType> value = getRaw(u, v);
 
    if (value == this->noData()) {
      return propertyValueViewToCopy(this->defaultValue());
    } else if constexpr (IsMetadataNumeric<ElementType>::value) {
      return transformValue(value, this->offset(), this->scale());
    } else if constexpr (IsMetadataNumericArray<ElementType>::value) {
      return transformArray(
          propertyValueCopyToView(value),
          this->offset(),
          this->scale());
    } else {
      return value;
    }
  }
 
  PropertyValueViewToCopy<ElementType>
  getRaw(double u, double v) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyTexturePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
 
    std::vector<uint8_t> sample =
        this->sampleNearestPixel(u, v, this->_channels);
 
    return assembleValueFromChannels<ElementType>(
        std::span(sample.data(), this->_channels.size()));
  }
 
  const std::vector<int64_t>& getChannels() const noexcept {
    return this->_channels;
  }
 
  const std::string& getSwizzle() const noexcept { return this->_swizzle; }
 
private:
  std::vector<int64_t> _channels;
  std::string _swizzle;
};
 
#pragma endregion
 
#pragma region Normalized property
 
template <typename ElementType>
class PropertyTexturePropertyView<ElementType, true>
    : public PropertyView<ElementType, true>, public TextureView {
private:
  using NormalizedType = typename TypeToNormalizedType<ElementType>::type;
 
public:
  PropertyTexturePropertyView() noexcept
      : PropertyView<ElementType, true>(),
        TextureView(),
        _channels(),
        _swizzle() {}
 
  PropertyTexturePropertyView(PropertyViewStatusType status) noexcept
      : PropertyView<ElementType, true>(status),
        TextureView(),
        _channels(),
        _swizzle() {
    CESIUM_ASSERT(
        this->_status != PropertyTexturePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid "
        "status");
  }
 
  PropertyTexturePropertyView(const ClassProperty& classProperty) noexcept
      : PropertyView<ElementType, true>(classProperty),
        TextureView(),
        _channels(),
        _swizzle() {
    if (this->_status != PropertyTexturePropertyViewStatus::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 =
          PropertyTexturePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status = PropertyTexturePropertyViewStatus::EmptyPropertyWithDefault;
  }
 
  PropertyTexturePropertyView(
      const PropertyTextureProperty& property,
      const ClassProperty& classProperty,
      const Sampler& sampler,
      const ImageAsset& image,
      const TextureViewOptions& options = TextureViewOptions()) noexcept
      : PropertyView<ElementType, true>(classProperty, property),
        TextureView(
            sampler,
            image,
            property.texCoord,
            property.getExtension<ExtensionKhrTextureTransform>(),
            options),
        _channels(property.channels),
        _swizzle() {
    if (this->_status != PropertyTexturePropertyViewStatus::Valid) {
      return;
    }
 
    switch (this->getTextureViewStatus()) {
    case TextureViewStatus::Valid:
      break;
    case TextureViewStatus::ErrorInvalidSampler:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidSampler;
      return;
    case TextureViewStatus::ErrorInvalidImage:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidImage;
      return;
    case TextureViewStatus::ErrorEmptyImage:
      this->_status = PropertyTexturePropertyViewStatus::ErrorEmptyImage;
      return;
    case TextureViewStatus::ErrorInvalidBytesPerChannel:
      this->_status =
          PropertyTexturePropertyViewStatus::ErrorInvalidBytesPerChannel;
      return;
    case TextureViewStatus::ErrorUninitialized:
    case TextureViewStatus::ErrorInvalidTexture:
    default:
      this->_status = PropertyTexturePropertyViewStatus::ErrorInvalidTexture;
      return;
    }
 
    _swizzle.reserve(_channels.size());
    for (size_t i = 0; i < _channels.size(); ++i) {
      switch (_channels[i]) {
      case 0:
        _swizzle += "r";
        break;
      case 1:
        _swizzle += "g";
        break;
      case 2:
        _swizzle += "b";
        break;
      case 3:
        _swizzle += "a";
        break;
      default:
        CESIUM_ASSERT(
            false && "A valid channels vector must be passed to the view.");
      }
    }
  }
 
  std::optional<PropertyValueViewToCopy<NormalizedType>>
  get(double u, double v) const noexcept {
    if (this->_status ==
        PropertyTexturePropertyViewStatus::EmptyPropertyWithDefault) {
      return propertyValueViewToCopy(this->defaultValue());
    }
 
    PropertyValueViewToCopy<ElementType> value = getRaw(u, v);
 
    if (value == this->noData()) {
      return propertyValueViewToCopy(this->defaultValue());
    } else if constexpr (IsMetadataScalar<ElementType>::value) {
      return transformValue<NormalizedType>(
          normalize<ElementType>(value),
          this->offset(),
          this->scale());
    } else 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());
    } else if constexpr (IsMetadataArray<ElementType>::value) {
      using ArrayElementType = typename MetadataArrayType<ElementType>::type;
      if constexpr (IsMetadataScalar<ArrayElementType>::value) {
        return transformNormalizedArray<ArrayElementType>(
            propertyValueCopyToView(value),
            this->offset(),
            this->scale());
      } else if constexpr (IsMetadataVecN<ArrayElementType>::value) {
        constexpr glm::length_t N = ArrayElementType::length();
        using T = typename ArrayElementType::value_type;
        return transformNormalizedVecNArray<N, T>(
            propertyValueCopyToView(value),
            this->offset(),
            this->scale());
      }
    }
  }
 
  PropertyValueViewToCopy<ElementType>
  getRaw(double u, double v) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyTexturePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
 
    std::vector<uint8_t> sample =
        this->sampleNearestPixel(u, v, this->_channels);
 
    return assembleValueFromChannels<ElementType>(
        std::span(sample.data(), this->_channels.size()));
  }
 
  const std::vector<int64_t>& getChannels() const noexcept {
    return this->_channels;
  }
 
  const std::string& getSwizzle() const noexcept { return this->_swizzle; }
 
private:
  std::vector<int64_t> _channels;
  std::string _swizzle;
};
#pragma endregion
 
} // namespace CesiumGltf