743 lines
25 KiB
C++
743 lines
25 KiB
C++
#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 {
|
|
/**
|
|
* @brief Indicates the status of a property attribute view.
|
|
*
|
|
* The {@link PropertyAttributeView} constructor always completes successfully.
|
|
* However it may not always reflect the actual content of the
|
|
* {@link PropertyAttribute}. This enumeration provides the reason.
|
|
*/
|
|
enum class PropertyAttributeViewStatus {
|
|
/**
|
|
* @brief This property attribute view is valid and ready to use.
|
|
*/
|
|
Valid,
|
|
|
|
/**
|
|
* @brief The glTF is missing the EXT_structural_metadata extension.
|
|
*/
|
|
ErrorMissingMetadataExtension,
|
|
|
|
/**
|
|
* @brief The glTF EXT_structural_metadata extension doesn't contain a schema.
|
|
*/
|
|
ErrorMissingSchema,
|
|
|
|
/**
|
|
* @brief The property attribute's specified class could not be found in the
|
|
* extension.
|
|
*/
|
|
ErrorClassNotFound
|
|
};
|
|
|
|
/**
|
|
* @brief Attempts to obtain a \ref PropertyType from the \ref Accessor::type
|
|
* "type" field of the accessor.
|
|
*
|
|
* @param accessor The accessor whose type will be obtained.
|
|
* @returns A \ref PropertyType equivalent to the accessor's \ref
|
|
* AccessorSpec::type, or \ref PropertyType::Invalid if no conversion could be
|
|
* made.
|
|
*/
|
|
PropertyType getAccessorTypeAsPropertyType(const Accessor& accessor);
|
|
|
|
/**
|
|
* @brief Attempts to obtain a \ref PropertyComponentType from the \ref
|
|
* Accessor::componentType "componentType" field of the accessor.
|
|
*
|
|
* @param accessor The accessor whose componentType will be obtained.
|
|
* @returns A \ref PropertyComponentType equivalent to the accessor's \ref
|
|
* AccessorSpec::componentType, or \ref PropertyComponentType::None if no
|
|
* conversion could be made.
|
|
*/
|
|
PropertyComponentType
|
|
getAccessorComponentTypeAsPropertyComponentType(const Accessor& accessor);
|
|
|
|
/**
|
|
* @brief A view on a {@link PropertyAttribute}.
|
|
*
|
|
* This should be used to get a {@link PropertyAttributePropertyView} of a property
|
|
* in the property attribute. It will validate the EXT_structural_metadata
|
|
* format and ensure {@link PropertyAttributePropertyView} does not access data out
|
|
* of bounds.
|
|
*/
|
|
class PropertyAttributeView {
|
|
public:
|
|
/**
|
|
* @brief Construct a PropertyAttributeView.
|
|
*
|
|
* @param model The glTF that contains the property attribute's data.
|
|
* @param propertyAttribute The {@link PropertyAttribute} from which
|
|
* the view will retrieve data.
|
|
*/
|
|
PropertyAttributeView(
|
|
const Model& model,
|
|
const PropertyAttribute& propertyAttribute) noexcept;
|
|
|
|
/**
|
|
* @brief Gets the status of this property attribute view.
|
|
*
|
|
* Indicates whether the view accurately reflects the property attribute's
|
|
* data, or whether an error occurred.
|
|
*/
|
|
PropertyAttributeViewStatus status() const noexcept { return this->_status; }
|
|
|
|
/**
|
|
* @brief Gets the name of the property attribute being viewed. Returns
|
|
* std::nullopt if no name was specified.
|
|
*/
|
|
const std::optional<std::string>& name() const noexcept {
|
|
return _pPropertyAttribute->name;
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the {@link Class} that this property attribute conforms to.
|
|
*
|
|
* @return A pointer to the {@link Class}. Returns nullptr if the
|
|
* PropertyAttribute did not specify a valid class.
|
|
*/
|
|
const Class* getClass() const noexcept { return _pClass; }
|
|
|
|
/**
|
|
* @brief Finds the {@link ClassProperty} that
|
|
* describes the type information of the property with the specified id.
|
|
* @param propertyId The id of the property to retrieve the class for.
|
|
* @return A pointer to the {@link ClassProperty}.
|
|
* Return nullptr if the PropertyAttributeView is invalid or if no class
|
|
* property was found.
|
|
*/
|
|
const ClassProperty* getClassProperty(const std::string& propertyId) const;
|
|
|
|
/**
|
|
* @brief Gets a {@link PropertyAttributePropertyView} that views the data of a
|
|
* property stored in the {@link PropertyAttribute}.
|
|
*
|
|
* This method will validate the EXT_structural_metadata format to ensure
|
|
* {@link PropertyAttributePropertyView} retrieves the correct data. T must
|
|
* be a scalar with a supported component type (int8_t, uint8_t, int16_t,
|
|
* uint16_t, float), a glm vecN composed of one of the scalar types,
|
|
* or a glm matN containing one of the scalar types.
|
|
*
|
|
* If T does not match the type specified by the class property, this returns
|
|
* an invalid PropertyAttributePropertyView. Likewise, if the value of
|
|
* Normalized does not match the value of {@link ClassProperty::normalized} for that
|
|
* class property, this returns an invalid property view. Only types with
|
|
* integer components may be normalized.
|
|
*
|
|
* @tparam T The C++ type corresponding to the type of the data retrieved.
|
|
* @tparam Normalized Whether the property is normalized. Only applicable to
|
|
* types with integer components.
|
|
* @param primitive The target primitive
|
|
* @param propertyId The id of the property to retrieve data from
|
|
* @return A {@link PropertyAttributePropertyView} of the property. If no valid
|
|
* property is found, the property view will be invalid.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets a {@link PropertyAttributePropertyView} through a callback that accepts a
|
|
* property id and a {@link PropertyAttributePropertyView} that views the data
|
|
* of the property with the specified id.
|
|
*
|
|
* This method will validate the EXT_structural_metadata format to ensure
|
|
* {@link PropertyAttributePropertyView} retrieves the correct data. T must
|
|
* be a scalar with a supported component type (int8_t, uint8_t, int16_t,
|
|
* uint16_t, float), a glm vecN composed of one of the scalar types,
|
|
* or a glm matN containing one of the scalar types.
|
|
*
|
|
* If the property is somehow invalid, an empty {@link PropertyAttributePropertyView}
|
|
* with an error status will be passed to the callback. Otherwise, a valid
|
|
* property view will be passed to the callback.
|
|
*
|
|
* @param primitive The target primitive
|
|
* @param propertyId The id of the property to retrieve data from
|
|
* @param callback A callback function that accepts a property id and a
|
|
* {@link PropertyAttributePropertyView}
|
|
* @tparam Callback The type of the callback function.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* @brief Iterates over each property in the {@link PropertyAttribute} with a callback
|
|
* that accepts a property id and a {@link PropertyAttributePropertyView} to view
|
|
* the data stored in the {@link PropertyAttributeProperty}.
|
|
*
|
|
* This method will validate the EXT_structural_metadata format to ensure
|
|
* {@link PropertyAttributePropertyView} retrieves the correct data. T must be
|
|
* a scalar with a supported component type (int8_t, uint8_t, int16_t,
|
|
* uint16_t, float), a glm vecN composed of one of the scalar types,
|
|
* or a PropertyArrayView containing one of the scalar types.
|
|
*
|
|
* If the property is invalid, an empty {@link PropertyAttributePropertyView} with an
|
|
* error status will be passed to the callback. Otherwise, a valid property
|
|
* view will be passed to the callback.
|
|
*
|
|
* @param primitive The id of the property to retrieve data from
|
|
* @param callback A callback function that accepts property id and
|
|
* {@link PropertyAttributePropertyView}
|
|
* @tparam Callback The type of the callback function.
|
|
*/
|
|
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
|