AccessorView.h

#pragma once
 
#include <CesiumGltf/Accessor.h>
#include <CesiumGltf/Model.h>
 
#include <cstddef>
#include <stdexcept>
 
namespace CesiumGltf {

enum class AccessorViewStatus {
  Valid,

  InvalidAccessorIndex,

  InvalidBufferViewIndex,

  InvalidBufferIndex,

  BufferViewTooSmall,

  BufferTooSmall,

  WrongSizeT,

  InvalidType,

  InvalidComponentType,

  InvalidByteStride,
};

template <class T> class AccessorView final {
private:
  const std::byte* _pData;
  int64_t _stride;
  int64_t _offset;
  int64_t _size;
  bool _normalized;
  AccessorViewStatus _status;
 
public:
  typedef T value_type;

  AccessorView(
      AccessorViewStatus status = AccessorViewStatus::InvalidAccessorIndex)
      : _pData(nullptr),
        _stride(0),
        _offset(0),
        _size(0),
        _normalized(false),
        _status(status) {}

  AccessorView(
      const std::byte* pData,
      int64_t stride,
      int64_t offset,
      int64_t size,
      bool normalized)
      : _pData(pData),
        _stride(stride),
        _offset(offset),
        _size(size),
        _normalized(normalized),
        _status(AccessorViewStatus::Valid) {}

  AccessorView(const Model& model, const Accessor& accessor) noexcept
      : AccessorView() {
    this->create(model, accessor);
  }

  AccessorView(const Model& model, int32_t accessorIndex) noexcept
      : AccessorView() {
    const Accessor* pAccessor = Model::getSafe(&model.accessors, accessorIndex);
    if (!pAccessor) {
      this->_status = AccessorViewStatus::InvalidAccessorIndex;
      return;
    }
 
    this->create(model, *pAccessor);
  }

  const T& operator[](int64_t i) const {
    if (i < 0 || i >= this->_size) {
      throw std::range_error("index out of range");
    }
 
    return *reinterpret_cast<const T*>(
        this->_pData + i * this->_stride + this->_offset);
  }

  int64_t size() const noexcept { return this->_size; }

  AccessorViewStatus status() const noexcept { return this->_status; }

  int64_t stride() const noexcept { return this->_stride; }

  int64_t offset() const noexcept { return this->_offset; }

  bool normalized() const noexcept { return this->_normalized; }

  const std::byte* data() const noexcept {
    return this->_pData + this->_offset;
  }
 
private:
  void create(const Model& model, const Accessor& accessor) noexcept {
    const CesiumGltf::BufferView* pBufferView =
        Model::getSafe(&model.bufferViews, accessor.bufferView);
    if (!pBufferView) {
      this->_status = AccessorViewStatus::InvalidBufferViewIndex;
      return;
    }
 
    const CesiumGltf::Buffer* pBuffer =
        Model::getSafe(&model.buffers, pBufferView->buffer);
    if (!pBuffer) {
      this->_status = AccessorViewStatus::InvalidBufferIndex;
      return;
    }
 
    const std::vector<std::byte>& data = pBuffer->cesium.data;
    const int64_t bufferBytes = int64_t(data.size());
    if (pBufferView->byteOffset + pBufferView->byteLength > bufferBytes) {
      this->_status = AccessorViewStatus::BufferTooSmall;
      return;
    }
 
    const int64_t accessorByteStride = accessor.computeByteStride(model);
    if (accessorByteStride < 0) {
      this->_status = AccessorViewStatus::InvalidByteStride;
      return;
    }
 
    const int64_t accessorComponentElements =
        accessor.computeNumberOfComponents();
    const int64_t accessorComponentBytes =
        accessor.computeByteSizeOfComponent();
    const int64_t accessorBytesPerStride =
        accessorComponentElements * accessorComponentBytes;
 
    if (sizeof(T) != accessorBytesPerStride) {
      this->_status = AccessorViewStatus::WrongSizeT;
      return;
    }
 
    const int64_t accessorBytes = accessorByteStride * accessor.count;
    const int64_t bytesRemainingInBufferView =
        pBufferView->byteLength -
        (accessor.byteOffset + accessorByteStride * (accessor.count - 1) +
         accessorBytesPerStride);
    if (accessorBytes > pBufferView->byteLength ||
        bytesRemainingInBufferView < 0) {
      this->_status = AccessorViewStatus::BufferViewTooSmall;
      return;
    }
 
    this->_pData = pBuffer->cesium.data.data();
    this->_stride = accessorByteStride;
    this->_offset = accessor.byteOffset + pBufferView->byteOffset;
    this->_size = accessor.count;
    this->_normalized = accessor.normalized;
    this->_status = AccessorViewStatus::Valid;
  }
};

struct AccessorTypes {
#pragma pack(push, 1)

  template <typename T> struct SCALAR {
    T value[1];
  };

  template <typename T> struct VEC2 {
    T value[2];
  };

  template <typename T> struct VEC3 {
    T value[3];
  };

  template <typename T> struct VEC4 {
    T value[4];
  };

  template <typename T> struct MAT2 {
    T value[4];
  };

  template <typename T> struct MAT3 {
    T value[9];
  };

  template <typename T> struct MAT4 {
    T value[16];
  };
 
#pragma pack(pop)
};
 
namespace CesiumImpl {
template <typename TCallback, typename TElement>
std::invoke_result_t<TCallback, AccessorView<AccessorTypes::SCALAR<TElement>>>
createAccessorView(
    const Model& model,
    const Accessor& accessor,
    TCallback&& callback) {
  if (accessor.type == Accessor::Type::SCALAR) {
    return callback(
        AccessorView<AccessorTypes::SCALAR<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::VEC2) {
    return callback(
        AccessorView<AccessorTypes::VEC2<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::VEC3) {
    return callback(
        AccessorView<AccessorTypes::VEC3<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::VEC4) {
    return callback(
        AccessorView<AccessorTypes::VEC4<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::MAT2) {
    return callback(
        AccessorView<AccessorTypes::MAT2<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::MAT3) {
    return callback(
        AccessorView<AccessorTypes::MAT3<TElement>>(model, accessor));
  }
  if (accessor.type == Accessor::Type::MAT4) {
    return callback(
        AccessorView<AccessorTypes::MAT4<TElement>>(model, accessor));
  }
  // TODO Print a warning here???
  return callback(AccessorView<AccessorTypes::SCALAR<TElement>>(
      AccessorViewStatus::InvalidType));
}
} // namespace CesiumImpl

template <typename TCallback>
std::invoke_result_t<TCallback, AccessorView<AccessorTypes::SCALAR<float>>>
createAccessorView(
    const Model& model,
    const Accessor& accessor,
    TCallback&& callback) {
  switch (accessor.componentType) {
  case Accessor::ComponentType::BYTE:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, int8_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::UNSIGNED_BYTE:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, uint8_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::SHORT:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, int16_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::UNSIGNED_SHORT:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, uint16_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::INT:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, int32_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::UNSIGNED_INT:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, uint32_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::INT64:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, int64_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::UNSIGNED_INT64:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, uint64_t>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::FLOAT:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, float>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  case Accessor::ComponentType::DOUBLE:
    return ::CesiumGltf::CesiumImpl::createAccessorView<TCallback, double>(
        model,
        accessor,
        std::forward<TCallback>(callback));
  default:
    return callback(AccessorView<AccessorTypes::SCALAR<float>>(
        AccessorViewStatus::InvalidComponentType));
  }
}

template <typename TCallback>
std::invoke_result_t<TCallback, AccessorView<AccessorTypes::SCALAR<float>>>
createAccessorView(
    const Model& model,
    int32_t accessorIndex,
    TCallback&& callback) {
  const Accessor* pAccessor = Model::getSafe(&model.accessors, accessorIndex);
  if (!pAccessor) {
    return callback(AccessorView<AccessorTypes::SCALAR<float>>(
        AccessorViewStatus::InvalidComponentType));
  }
 
  return createAccessorView(model, *pAccessor, callback);
}
} // namespace CesiumGltf