ralpha
/
ralpha-assets
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ralpha-assets/Plugins/CesiumForUnreal/Source/CesiumRuntime/Private/Tests/CesiumPropertyAttributeProp...

3256 lines
114 KiB
C++
Raw Permalink Blame History

// Copyright 2020-2024 CesiumGS, Inc. and Contributors
#include "CesiumPropertyAttributeProperty.h"
#include "CesiumGltfSpecUtility.h"
#include "Misc/AutomationTest.h"
#include <limits>
BEGIN_DEFINE_SPEC(
FCesiumPropertyAttributePropertySpec,
"Cesium.Unit.PropertyAttributeProperty",
EAutomationTestFlags::EditorContext | EAutomationTestFlags::ClientContext |
EAutomationTestFlags::ServerContext |
EAutomationTestFlags::CommandletContext |
EAutomationTestFlags::ProductFilter)
END_DEFINE_SPEC(FCesiumPropertyAttributePropertySpec)
void FCesiumPropertyAttributePropertySpec::Define() {
using namespace CesiumGltf;
Describe("Constructor", [this]() {
It("constructs invalid instance by default", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
FCesiumMetadataValueType expectedType; // Invalid type
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
0);
});
It("constructs invalid instance from view with invalid definition",
[this]() {
PropertyAttributePropertyView<int8_t> propertyView(
PropertyAttributePropertyViewStatus::ErrorTypeMismatch);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
FCesiumMetadataValueType expectedType; // Invalid type
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
0);
});
It("constructs invalid instance from view with invalid data", [this]() {
PropertyAttributePropertyView<int8_t> propertyView(
PropertyAttributePropertyViewStatus::
ErrorAccessorComponentTypeMismatch);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidPropertyData);
FCesiumMetadataValueType expectedType; // Invalid type
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
0);
});
It("constructs valid instance", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT32;
std::vector<uint32_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint32_t> accessorView(
data.data(),
sizeof(uint32_t),
0,
values.size());
PropertyAttributePropertyView<uint32_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
int64_t(values.size()));
FCesiumMetadataValueType expectedType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Uint32,
false);
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual(
"BlueprintType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetBlueprintType(
property),
ECesiumMetadataBlueprintType::Integer64);
TestFalse(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
// Check that undefined properties return empty values
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetOffset(property);
TestTrue("Offset", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetScale(property);
TestTrue("Scale", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetMaximumValue(
property);
TestTrue("Max", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetMinimumValue(
property);
TestTrue("Min", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetNoDataValue(
property);
TestTrue("NoData", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetDefaultValue(
property);
TestTrue("Default", UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
});
It("constructs valid normalized instance", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
std::vector<int8_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int8_t> accessorView(
data.data(),
sizeof(int8_t),
0,
values.size());
PropertyAttributePropertyView<int8_t, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
int64_t(values.size()));
FCesiumMetadataValueType expectedType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Int8,
false);
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual(
"BlueprintType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetBlueprintType(
property),
ECesiumMetadataBlueprintType::Integer);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
});
It("constructs valid instance with additional properties", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
double offset = 1.0;
double scale = 2.0;
double min = 1.0;
double max = 3.0;
int8_t noData = 1;
double defaultValue = 12.3;
classProperty.offset = offset;
classProperty.scale = scale;
classProperty.min = min;
classProperty.max = max;
classProperty.noData = noData;
classProperty.defaultProperty = defaultValue;
std::vector<int8_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int8_t> accessorView(
data.data(),
sizeof(int8_t),
0,
values.size());
PropertyAttributePropertyView<int8_t, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"Size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
int64_t(values.size()));
FCesiumMetadataValueType expectedType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Int8,
false);
TestTrue(
"ValueType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValueType(
property) == expectedType);
TestEqual(
"BlueprintType",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetBlueprintType(
property),
ECesiumMetadataBlueprintType::Integer);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetOffset(property);
TestEqual(
"Offset",
UCesiumMetadataValueBlueprintLibrary::GetFloat64(value, 0.0),
offset);
value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetScale(property);
TestEqual(
"Scale",
UCesiumMetadataValueBlueprintLibrary::GetFloat64(value, 0.0),
scale);
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetMaximumValue(
property);
TestEqual(
"Max",
UCesiumMetadataValueBlueprintLibrary::GetFloat64(value, 0.0),
max);
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetMinimumValue(
property);
TestEqual(
"Min",
UCesiumMetadataValueBlueprintLibrary::GetFloat64(value, 0.0),
min);
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetNoDataValue(
property);
TestEqual(
"NoData",
UCesiumMetadataValueBlueprintLibrary::GetInteger(value, 0.0),
noData);
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetDefaultValue(
property);
TestEqual(
"Default",
UCesiumMetadataValueBlueprintLibrary::GetFloat64(value, 0.0),
defaultValue);
});
});
Describe("GetByte", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
0),
0);
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
std::vector<uint8_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint8_t> accessorView(
data.data(),
sizeof(uint8_t),
0,
values.size());
PropertyAttributePropertyView<uint8_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
-1),
0);
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
10),
0);
});
It("gets from uint8 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
std::vector<uint8_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint8_t> accessorView(
data.data(),
sizeof(uint8_t),
0,
values.size());
PropertyAttributePropertyView<uint8_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
int64_t(i)),
values[i]);
}
});
It("converts compatible values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-1.0f, 2.0f, 256.0f, 4.0f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<uint8_t> expected{0, 2, 0, 4};
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
int64_t(i),
0),
expected[i]);
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
uint8_t noDataValue = 0;
uint8_t defaultValue = 255;
classProperty.noData = noDataValue;
classProperty.defaultProperty = defaultValue;
std::vector<uint8_t> values{1, 2, 3, 0};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint8> accessorView(
data.data(),
sizeof(uint8),
0,
values.size());
PropertyAttributePropertyView<uint8> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
if (values[i] == noDataValue) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
int64_t(i)),
defaultValue);
} else {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetByte(
property,
int64_t(i)),
values[i]);
}
}
});
});
Describe("GetInteger", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
0),
0);
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
std::vector<int16_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
-1),
0);
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
10),
0);
});
It("gets from int16 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
std::vector<int16_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
int64_t(i)),
values[i]);
}
});
It("converts compatible values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{
-1.0f,
2.0f,
float(std::numeric_limits<uint32_t>::max()),
4.0f,
2.54f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<int32_t> expected{-1, 2, 0, 4, 2};
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
int64_t(i)),
expected[i]);
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
int16_t noDataValue = -1;
int16_t defaultValue = 10;
classProperty.noData = noDataValue;
classProperty.defaultProperty = defaultValue;
std::vector<int16_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
if (values[i] == noDataValue) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
int64_t(i)),
defaultValue);
} else {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger(
property,
int64_t(i)),
values[i]);
}
}
});
});
Describe("GetInteger64", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
0),
0);
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT32;
std::vector<uint32_t>
values{1, 2, 3, 4, std::numeric_limits<uint32_t>::max()};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint32_t> accessorView(
data.data(),
sizeof(uint32_t),
0,
values.size());
PropertyAttributePropertyView<uint32_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual<int64_t>(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
-1),
0);
TestEqual<int64_t>(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
10),
0);
});
It("gets from uint32 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT32;
std::vector<uint32_t>
values{1, 2, 3, 4, std::numeric_limits<uint32_t>::max()};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint32_t> accessorView(
data.data(),
sizeof(uint32_t),
0,
values.size());
PropertyAttributePropertyView<uint32_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual<int64_t>(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
int64_t(i)),
int64_t(values[i]));
}
});
It("converts compatible values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{
float(std::numeric_limits<uint64_t>::max()),
2.0f,
float(std::numeric_limits<uint32_t>::max()),
4.0f,
2.54f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<int64_t> expected{0, 2, int64_t(values[2]), 4, 2};
for (size_t i = 0; i < values.size(); i++) {
TestEqual<int64_t>(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
int64_t(i)),
expected[i]);
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
int32_t noDataValue = -1;
int32_t defaultValue = 10;
classProperty.noData = noDataValue;
classProperty.defaultProperty = defaultValue;
std::vector<int16_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
if (values[i] == noDataValue) {
TestEqual<int64_t>(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
int64_t(i)),
defaultValue);
} else {
TestEqual<int64_t>(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetInteger64(
property,
int64_t(i)),
values[i]);
}
}
});
});
Describe("GetFloat", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
0),
0.0f);
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-1.54f, 52.78f, -39.0f, 4.005f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
-1),
0.0f);
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
10),
0.0f);
});
It("gets from float property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-1.54f, 52.78f, -39.0f, 4.005f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
i),
values[i]);
}
});
It("converts integer values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<int8_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int8_t> accessorView(
data.data(),
sizeof(int8_t),
0,
values.size());
PropertyAttributePropertyView<int8_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
i),
static_cast<float>(values[i]));
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
float offset = 5.0f;
float scale = 2.0f;
classProperty.offset = offset;
classProperty.scale = scale;
std::vector<float> values{-1.1f, 2.2f, -3.3f, 4.0f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat(
property,
i),
values[i] * scale + offset);
}
});
});
Describe("GetFloat64", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
0),
0.0);
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-1.1, 2.2, -3.3, 4.0};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
-1),
0.0);
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
10),
0.0);
});
It("gets float values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-1.1, 2.2, -3.3, 4.0};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
i),
double(values[i]));
}
});
It("gets from normalized uint8 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
classProperty.normalized = true;
std::vector<uint8_t> values{0, 128, 255, 0};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint8_t> accessorView(
data.data(),
sizeof(uint8_t),
0,
values.size());
PropertyAttributePropertyView<uint8_t, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
i),
double(values[i]) / 255.0);
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
classProperty.normalized = true;
float offset = 5.0;
float scale = 2.0;
classProperty.offset = offset;
classProperty.scale = scale;
std::vector<uint8_t> values{0, 128, 255, 0};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint8_t> accessorView(
data.data(),
sizeof(uint8_t),
0,
values.size());
PropertyAttributePropertyView<uint8, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetFloat64(
property,
i),
(double(values[i]) / 255.0) * scale + offset);
}
});
});
Describe("GetIntPoint", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntPoint(
property,
0,
FIntPoint(0)),
FIntPoint(0));
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<glm::i8vec2> values{
glm::i8vec2(1, 1),
glm::i8vec2(-1, -1),
glm::i8vec2(2, 4),
glm::i8vec2(0, -8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec2> accessorView(
data.data(),
sizeof(glm::i8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
-1,
FIntVector(0)),
FIntVector(0));
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
10,
FIntVector(0)),
FIntVector(0));
});
It("gets from i8vec2 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<glm::i8vec2> values{
glm::i8vec2(1, 1),
glm::i8vec2(-1, -1),
glm::i8vec2(2, 4),
glm::i8vec2(0, -8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec2> accessorView(
data.data(),
sizeof(glm::i8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FIntPoint expected(values[i][0], values[i][1]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntPoint(
property,
int64_t(i),
FIntPoint(0)),
expected);
}
});
It("converts compatible values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{
1.234f,
-24.5f,
std::numeric_limits<float>::lowest(),
2456.80f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<int32_t> expected{1, -24, 0, 2456};
for (size_t i = 0; i < values.size(); i++) {
FIntPoint expectedIntPoint(expected[i]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntPoint(
property,
int64_t(i),
FIntPoint(0)),
expectedIntPoint);
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::INT8;
glm::i8vec2 noData(-1, -1);
FIntPoint defaultValue(5, 22);
classProperty.noData = {noData[0], noData[1]};
classProperty.defaultProperty = {defaultValue[0], defaultValue[1]};
std::vector<glm::i8vec2> values{
glm::i8vec2(1, 1),
glm::i8vec2(-1, -1),
glm::i8vec2(2, 4),
glm::i8vec2(0, -8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec2> accessorView(
data.data(),
sizeof(glm::i8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FIntPoint expected;
if (values[i] == noData) {
expected = defaultValue;
} else {
expected = FIntPoint(values[i][0], values[i][1]);
}
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntPoint(
property,
int64_t(i),
FIntPoint(0)),
expected);
}
});
});
Describe("GetVector2D", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
0,
FVector2D::Zero()),
FVector2D::Zero());
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec2> values{
glm::vec2(1.0f, 1.1f),
glm::vec2(-1.0f, -0.1f),
glm::vec2(2.2f, 4.2f),
glm::vec2(0.0f, -8.0f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec2> accessorView(
data.data(),
sizeof(glm::vec2),
0,
values.size());
PropertyAttributePropertyView<glm::vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
-1,
FVector2D::Zero()),
FVector2D::Zero());
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
10,
FVector2D::Zero()),
FVector2D::Zero());
});
It("gets from glm::vec2 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec2> values{
glm::vec2(1.0f, 1.1f),
glm::vec2(-1.0f, -0.1f),
glm::vec2(2.2f, 4.2f),
glm::vec2(0.0f, -8.0f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec2> accessorView(
data.data(),
sizeof(glm::vec2),
0,
values.size());
PropertyAttributePropertyView<glm::vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
int64_t(i),
FVector2D::Zero()),
FVector2D(values[i][0], values[i][1]));
}
});
It("gets from normalized glm::u8vec2 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
classProperty.normalized = true;
std::vector<glm::u8vec2> values{
glm::u8vec2(1, 1),
glm::u8vec2(0, 255),
glm::u8vec2(10, 4),
glm::u8vec2(128, 8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::u8vec2> accessorView(
data.data(),
sizeof(glm::u8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::u8vec2, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
for (size_t i = 0; i < values.size(); i++) {
glm::dvec2 expected = glm::dvec2(values[i][0], values[i][1]) / 255.0;
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
int64_t(i),
FVector2D::Zero()),
FVector2D(expected[0], expected[1]));
}
});
It("converts unnormalized glm::u8vec2 values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
std::vector<glm::u8vec2> values{
glm::u8vec2(1, 1),
glm::u8vec2(0, 255),
glm::u8vec2(10, 4),
glm::u8vec2(128, 8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::u8vec2> accessorView(
data.data(),
sizeof(glm::u8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::u8vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
int64_t(i),
FVector2D::Zero()),
FVector2D(values[i][0], values[i][1]));
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
classProperty.normalized = true;
FVector2D offset(3.0, 2.4);
FVector2D scale(2.0, -1.0);
classProperty.offset = {offset[0], offset[1]};
classProperty.scale = {scale[0], scale[1]};
std::vector<glm::u8vec2> values{
glm::u8vec2(1, 1),
glm::u8vec2(0, 255),
glm::u8vec2(10, 4),
glm::u8vec2(128, 8)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::u8vec2> accessorView(
data.data(),
sizeof(glm::u8vec2),
0,
values.size());
PropertyAttributePropertyView<glm::u8vec2, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FVector2D expected(
double(values[i][0]) / 255.0 * scale[0] + offset[0],
double(values[i][1]) / 255.0 * scale[1] + offset[1]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector2D(
property,
int64_t(i),
FVector2D::Zero()),
expected);
}
});
});
Describe("GetIntVector", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
0,
FIntVector(0)),
FIntVector(0));
});
It("gets from glm::i8vec3 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<glm::i8vec3> values{
glm::i8vec3(1, 1, -1),
glm::i8vec3(-1, -1, 2),
glm::i8vec3(0, 4, 2),
glm::i8vec3(10, 8, 5)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec3> accessorView(
data.data(),
sizeof(glm::i8vec3),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FIntVector expected(values[i][0], values[i][1], values[i][2]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
i,
FIntVector(0)),
expected);
}
});
It("converts compatible values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{
1.234f,
-24.5f,
std::numeric_limits<float>::lowest(),
2456.80f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<int32_t> expected{1, -24, 0, 2456};
for (size_t i = 0; i < values.size(); i++) {
FIntVector expectedIntVector(expected[i]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
i,
FIntVector(0)),
expectedIntVector);
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::INT8;
glm::i8vec3 noData(-1, -1, 2);
FIntVector defaultValue(1, 2, 3);
classProperty.noData = {noData[0], noData[1], noData[2]};
classProperty.defaultProperty = {
defaultValue[0],
defaultValue[1],
defaultValue[2]};
std::vector<glm::i8vec3> values{
glm::i8vec3(1, 1, -1),
glm::i8vec3(-1, -1, 2),
glm::i8vec3(0, 4, 2),
glm::i8vec3(10, 8, 5)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec3> accessorView(
data.data(),
sizeof(glm::i8vec3),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FIntVector expected;
if (values[i] == noData) {
expected = defaultValue;
} else {
expected = FIntVector(values[i][0], values[i][1], values[i][2]);
}
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetIntVector(
property,
i,
FIntVector(0)),
expected);
}
});
});
Describe("GetVector3f", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
0,
FVector3f::Zero()),
FVector3f::Zero());
});
It("returns default value for invalid index", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec3> values{
glm::vec3(1.0f, 1.9f, -1.0f),
glm::vec3(-1.0f, -1.8f, 2.5f),
glm::vec3(10.0f, 4.4f, 5.4f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec3> accessorView(
data.data(),
sizeof(glm::vec3),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
-1,
FVector3f::Zero()),
FVector3f::Zero());
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
10,
FVector3f::Zero()),
FVector3f::Zero());
});
It("gets from glm::vec3 property", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec3> values{
glm::vec3(1.0f, 1.9f, -1.0f),
glm::vec3(-1.0f, -1.8f, 2.5f),
glm::vec3(10.0f, 4.4f, 5.4f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec3> accessorView(
data.data(),
sizeof(glm::vec3),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FVector3f expected(values[i][0], values[i][1], values[i][2]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
int64_t(i),
FVector3f(0)),
expected);
}
});
It("converts vec2 values", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec2> values{
glm::vec2(1.0f, 2.0f),
glm::vec2(-5.9f, 8.2f),
glm::vec2(20.5f, 2.0f),
glm::vec2(-1.0f, -1.0f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec2> accessorView(
data.data(),
sizeof(glm::vec2),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<FVector3f> expected(4);
for (size_t i = 0; i < values.size(); i++) {
expected[i] = FVector3f(float(values[i][0]), float(values[i][1]), 0.0f);
}
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
int64_t(i),
FVector3f::Zero()),
expected[i]);
}
});
It("gets with offset / scale", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
FVector3f offset(1.0f, 4.5f, -2.0f);
FVector3f scale(0.5f, -1.0f, 2.2f);
classProperty.offset = {offset[0], offset[1], offset[2]};
classProperty.scale = {scale[0], scale[1], scale[2]};
std::vector<glm::vec3> values{
glm::vec3(1.0f, 1.9f, -1.0f),
glm::vec3(-1.0f, -1.8f, 2.5f),
glm::vec3(10.0f, 4.4f, 5.4f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec3> accessorView(
data.data(),
sizeof(glm::vec3),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FVector3f expected(
values[i][0] * scale[0] + offset[0],
values[i][1] * scale[1] + offset[1],
values[i][2] * scale[2] + offset[2]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector3f(
property,
int64_t(i),
FVector3f::Zero()),
expected);
}
});
});
Describe("GetVector", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
0,
FVector::Zero()),
FVector::Zero());
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec3> values{
glm::vec3(1.02f, 0.1f, -1.11f),
glm::vec3(-1.0f, -1.0f, 2.0f),
glm::vec3(0.02f, 4.2f, 2.01f),
glm::vec3(10.0f, 8.067f, 5.213f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec3> accessorView(
data.data(),
sizeof(glm::vec3),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
-1,
FVector::Zero()),
FVector::Zero());
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
10,
FVector::Zero()),
FVector::Zero());
});
It("gets from glm::vec3 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec3> values{
glm::vec3(1.02f, 0.1f, -1.11f),
glm::vec3(-1.0f, -1.0f, 2.0f),
glm::vec3(0.02f, 4.2f, 2.01f),
glm::vec3(10.0f, 8.067f, 5.213f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec3> accessorView(
data.data(),
sizeof(glm::vec3),
0,
values.size());
PropertyAttributePropertyView<glm::vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestFalse(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
for (size_t i = 0; i < values.size(); i++) {
glm::dvec3 expected(values[i][0], values[i][1], values[i][2]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector::Zero()),
FVector(expected[0], expected[1], expected[2]));
}
});
It("gets from normalized glm::i8vec3 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
std::vector<glm::i8vec3> values{
glm::i8vec3(1, 1, -1),
glm::i8vec3(-1, -1, 2),
glm::i8vec3(0, 4, 2),
glm::i8vec3(10, 8, 5)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec3> accessorView(
data.data(),
sizeof(glm::i8vec3),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec3, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
for (size_t i = 0; i < values.size(); i++) {
glm::dvec3 expected =
glm::dvec3(values[i][0], values[i][1], values[i][2]) / 127.0;
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector::Zero()),
FVector(expected[0], expected[1], expected[2]));
}
});
It("converts unnormalized glm::i8vec3 values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<glm::i8vec3> values{
glm::i8vec3(1, 1, -1),
glm::i8vec3(-1, -1, 2),
glm::i8vec3(0, 4, 2),
glm::i8vec3(10, 8, 5)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec3> accessorView(
data.data(),
sizeof(glm::i8vec3),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec3> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector::Zero()),
FVector(values[i][0], values[i][1], values[i][2]));
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC3;
classProperty.componentType = ClassProperty::ComponentType::UINT8;
classProperty.normalized = true;
FVector offset(1.0, 2.0, 3.0);
FVector scale(0.5, -1.0, 2.0);
classProperty.offset = {offset[0], offset[1], offset[2]};
classProperty.scale = {scale[0], scale[1], scale[2]};
std::vector<glm::u8vec3> values{
glm::u8vec3(0, 128, 255),
glm::u8vec3(255, 255, 255),
glm::u8vec3(10, 20, 30),
glm::u8vec3(128, 0, 0)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::u8vec3> accessorView(
data.data(),
sizeof(glm::u8vec3),
0,
values.size());
PropertyAttributePropertyView<glm::u8vec3, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FVector expected(
double(values[i][0]) / 255.0 * scale[0] + offset[0],
double(values[i][1]) / 255.0 * scale[1] + offset[1],
double(values[i][2]) / 255.0 * scale[2] + offset[2]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector::Zero()),
expected);
}
});
});
Describe("GetVector4", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector4(
property,
0,
FVector4::Zero()),
FVector4::Zero());
});
It("returns default value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC4;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec4> values{
glm::vec4(1.02f, 0.1f, -1.11f, 1.0f),
glm::vec4(-1.0f, -1.0f, 2.0f, 0.0f),
glm::vec4(0.02f, 4.2f, 2.01f, 6.0f),
glm::vec4(10.0f, 8.067f, 5.213f, 0.0f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec4> accessorView(
data.data(),
sizeof(glm::vec4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
static_cast<int64_t>(values.size()));
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector4(
property,
-1,
FVector4::Zero()),
FVector4::Zero());
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector4(
property,
10,
FVector4::Zero()),
FVector4::Zero());
});
It("gets from glm::vec4 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC4;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec4> values{
glm::vec4(1.02f, 0.1f, -1.11f, 1.0f),
glm::vec4(-1.0f, -1.0f, 2.0f, 0.0f),
glm::vec4(0.02f, 4.2f, 2.01f, 6.0f),
glm::vec4(10.0f, 8.067f, 5.213f, 0.0f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec4> accessorView(
data.data(),
sizeof(glm::vec4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
glm::dvec4 expected(
values[i][0],
values[i][1],
values[i][2],
values[i][3]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector4(
property,
int64_t(i),
FVector4::Zero()),
FVector4(expected[0], expected[1], expected[2], expected[3]));
}
});
It("gets from normalized glm::i8vec4 property", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC4;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
std::vector<glm::i8vec4> values{
glm::i8vec4(1, 1, -1, 1),
glm::i8vec4(-1, -1, 2, 0),
glm::i8vec4(0, 4, 2, -8),
glm::i8vec4(10, 8, 5, 27)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec4> accessorView(
data.data(),
sizeof(glm::i8vec4),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec4, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
for (size_t i = 0; i < values.size(); i++) {
glm::dvec4 expected(
values[i][0],
values[i][1],
values[i][2],
values[i][3]);
expected /= 127.0;
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector4::Zero()),
FVector4(expected[0], expected[1], expected[2], expected[3]));
}
});
It("converts unnormalized glm::i8vec4 values", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC4;
classProperty.componentType = ClassProperty::ComponentType::INT8;
std::vector<glm::i8vec4> values{
glm::i8vec4(-1, 2, 5, 8),
glm::i8vec4(-1, -1, 2, 0),
glm::i8vec4(3, 5, 7, 0),
glm::i8vec4(1, -1, -2, 5)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec4> accessorView(
data.data(),
sizeof(glm::i8vec4),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
glm::dvec4 expected(
values[i][0],
values[i][1],
values[i][2],
values[i][3]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector4(
property,
int64_t(i),
FVector4::Zero()),
FVector4(expected[0], expected[1], expected[2], expected[3]));
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC4;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
FVector4 offset(1.0, 2.0, 3.0, -1.0);
FVector4 scale(0.5, -1.0, 2.0, 3.5);
classProperty.offset = {offset[0], offset[1], offset[2], offset[3]};
classProperty.scale = {scale[0], scale[1], scale[2], scale[3]};
std::vector<glm::i8vec4> values{
glm::i8vec4(1, 1, -1, 1),
glm::i8vec4(-1, -1, 2, 0),
glm::i8vec4(0, 4, 2, -8),
glm::i8vec4(10, 8, 5, 27)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8vec4> accessorView(
data.data(),
sizeof(glm::i8vec4),
0,
values.size());
PropertyAttributePropertyView<glm::i8vec4, true> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
FVector4 expected(
values[i][0] / 127.0 * scale[0] + offset[0],
values[i][1] / 127.0 * scale[1] + offset[1],
values[i][2] / 127.0 * scale[2] + offset[2],
values[i][3] / 127.0 * scale[3] + offset[3]);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetVector(
property,
int64_t(i),
FVector4::Zero()),
expected);
}
});
});
Describe("GetMatrix", [this]() {
It("returns default value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
TestEqual(
"value",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
0,
FMatrix::Identity),
FMatrix::Identity);
});
It("returns default value for invalid index", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::MAT4;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
// clang-format off
std::vector<glm::mat4> values{
glm::mat4(
1.0, 2.0, 3.0, 4.0,
5.0, 6.0, 7.0, 8.0,
9.0, 10.0, 11.0, 12.0,
13.0, 14.0, 15.0, 16.0),
glm::mat4(
1.0, 0.0, 0.0, 0.0,
0.0, -2.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
-1.5, 4.0, 2.0, 1.0),
};
// clang-format on
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::mat4> accessorView(
data.data(),
sizeof(glm::mat4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::mat4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual(
"negative index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
-1,
FMatrix::Identity),
FMatrix::Identity);
TestEqual(
"out-of-range positive index",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
10,
FMatrix::Identity),
FMatrix::Identity);
});
It("gets from glm::dmat4 property", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::MAT4;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
// clang-format off
std::vector<glm::mat4> values{
glm::mat4(
1.0, 2.0, 3.0, 4.0,
5.0, 6.0, 7.0, 8.0,
9.0, 10.0, 11.0, 12.0,
13.0, 14.0, 15.0, 16.0),
glm::mat4(
1.0, 0.0, 0.0, 0.0,
0.0, -2.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
-1.5, 4.0, 2.0, 1.0),
};
// clang-format on
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::mat4> accessorView(
data.data(),
sizeof(glm::mat4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::mat4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<FMatrix> expected(2);
expected[0] = FMatrix(
FPlane4d(1.0, 5.0, 9.0, 13.0),
FPlane4d(2.0, 6.0, 10.0, 14.0),
FPlane4d(3.0, 7.0, 11.0, 15.0),
FPlane4d(4.0, 8.0, 12.0, 16.0));
expected[1] = FMatrix(
FPlane4d(1.0, 0.0, 0.0, -1.5),
FPlane4d(0.0, -2.5, 0.0, 4.0),
FPlane4d(0.0, 0.0, 0.5, 2.0),
FPlane4d(0.0, 0.0, 0.0, 1.0));
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
int64_t(i),
FMatrix::Identity),
expected[i]);
}
});
It("gets from glm::u8mat4x4 property", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::MAT4;
classProperty.componentType = ClassProperty::ComponentType::INT8;
classProperty.normalized = true;
// clang-format off
std::vector<glm::i8mat4x4> values{
glm::i8mat4x4(
127, 0, 0, 0,
0, 127, 0, 0,
0, 0, 127, 0,
0, 0, -127, 127),
glm::i8mat4x4(
0, -127, 0, 0,
127, 0, 0, 0,
0, 0, 127, 0,
0, 0, 127, 127),
};
// clang-format on
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::i8mat4x4> accessorView(
data.data(),
sizeof(glm::i8mat4x4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::i8mat4x4, true>
propertyView(propertyAttributeProperty, classProperty, accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestTrue(
"IsNormalized",
UCesiumPropertyAttributePropertyBlueprintLibrary::IsNormalized(
property));
std::vector<FMatrix> expected(2);
expected[0] = FMatrix(
FPlane4d(1.0, 0.0, 0.0, 0.0),
FPlane4d(0.0, 1.0, 0.0, 0.0),
FPlane4d(0.0, 0.0, 1.0, -1.0),
FPlane4d(0.0, 0.0, 0.0, 1.0));
expected[1] = FMatrix(
FPlane4d(0.0, 1.0, 0.0, 0.0),
FPlane4d(-1.0, 0.0, 0.0, 0.0),
FPlane4d(0.0, 0.0, 1.0, 1.0),
FPlane4d(0.0, 0.0, 0.0, 1.0));
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
int64_t(i),
FMatrix::Identity),
expected[i]);
}
});
It("converts compatible values", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<float> values{-2.0f, 10.5f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<FMatrix> expected(2);
expected[0] = FMatrix(
FPlane4d(-2.0, 0.0, 0.0, 0.0),
FPlane4d(0.0, -2.0, 0.0, 0.0),
FPlane4d(0.0, 0.0, -2.0, 0.0),
FPlane4d(0.0, 0.0, 0.0, -2.0));
expected[1] = FMatrix(
FPlane4d(10.5, 0.0, 0.0, 0.0),
FPlane4d(0.0, 10.5, 0.0, 0.0),
FPlane4d(0.0, 0.0, 10.5, 0.0),
FPlane4d(0.0, 0.0, 0.0, 10.5));
for (size_t i = 0; i < expected.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
int64_t(i),
FMatrix::Identity),
expected[i]);
}
});
It("returns default values for incompatible type", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::VEC2;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
std::vector<glm::vec2> values{
glm::vec2(-2.0f, 10.5f),
glm::vec2(1.5f, 0.1f)};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::vec2> accessorView(
data.data(),
sizeof(glm::vec2),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::vec2> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
int64_t(i),
FMatrix::Identity),
FMatrix::Identity);
}
});
It("gets with offset / scale", [this]() {
CesiumGltf::PropertyAttributeProperty propertyAttributeProperty;
CesiumGltf::ClassProperty classProperty;
classProperty.type = ClassProperty::Type::MAT4;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
double offset = 1.0;
double scale = 2.0;
CesiumUtility::JsonValue::Array offsetArray(16);
CesiumUtility::JsonValue::Array scaleArray(16);
for (size_t i = 0; i < 16; i++) {
offsetArray[i] = offset;
scaleArray[i] = scale;
}
classProperty.offset = offsetArray;
classProperty.scale = scaleArray;
// clang-format off
std::vector<glm::mat4> values{
glm::mat4(
1.0, 2.0, 3.0, 4.0,
5.0, 6.0, 7.0, 8.0,
9.0, 10.0, 11.0, 12.0,
13.0, 14.0, 15.0, 16.0),
glm::mat4(
1.0, 0.0, 0.0, 0.0,
0.0, -2.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
-1.5, 4.0, 2.0, 1.0),
};
// clang-format on
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<glm::mat4> accessorView(
data.data(),
sizeof(glm::mat4),
0,
values.size());
CesiumGltf::PropertyAttributePropertyView<glm::mat4> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
std::vector<FMatrix> expected(2);
expected[0] = FMatrix(
FPlane4d(3.0, 11.0, 19.0, 27.0),
FPlane4d(5.0, 13.0, 21.0, 29.0),
FPlane4d(7.0, 15.0, 23.0, 31.0),
FPlane4d(9.0, 17.0, 25.0, 33.0));
expected[1] = FMatrix(
FPlane4d(3.0, 1.0, 1.0, -2.0),
FPlane4d(1.0, -4.0, 1.0, 9.0),
FPlane4d(1.0, 1.0, 2.0, 5.0),
FPlane4d(1.0, 1.0, 1.0, 3.0));
for (size_t i = 0; i < values.size(); i++) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumPropertyAttributePropertyBlueprintLibrary::GetMatrix(
property,
int64_t(i),
FMatrix::Identity),
expected[i]);
}
});
});
Describe("GetValue", [this]() {
It("returns empty value for invalid property", [this]() {
FCesiumPropertyAttributeProperty property;
TestEqual(
"PropertyAttributePropertyStatus",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::ErrorInvalidProperty);
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
0);
TestTrue(
"value empty",
UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
});
It("returns empty value for invalid index", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT32;
std::vector<uint32_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint32_t> accessorView(
data.data(),
sizeof(uint32_t),
0,
values.size());
PropertyAttributePropertyView<uint32_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
TestEqual<int64_t>(
"size",
UCesiumPropertyAttributePropertyBlueprintLibrary::GetPropertySize(
property),
int64_t(values.size()));
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
-1);
TestTrue(
"negative index",
UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
value = UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
10);
TestTrue(
"out-of-range positive index",
UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
});
It("gets value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::UINT32;
std::vector<uint32_t> values{1, 2, 3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<uint32_t> accessorView(
data.data(),
sizeof(uint32_t),
0,
values.size());
PropertyAttributePropertyView<uint32_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
FCesiumMetadataValueType valueType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Uint32,
false);
for (size_t i = 0; i < values.size(); i++) {
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
int64_t(i));
TestTrue(
"value type",
UCesiumMetadataValueBlueprintLibrary::GetValueType(value) ==
valueType);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumMetadataValueBlueprintLibrary::GetInteger(value, 0),
values[i]);
}
});
It("gets with offset / scale", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::FLOAT32;
float offset = 1.0f;
float scale = 2.0f;
classProperty.offset = offset;
classProperty.scale = scale;
std::vector<float> values{-1.1f, 2.0f, -3.5f, 4.0f};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<float> accessorView(
data.data(),
sizeof(float),
0,
values.size());
PropertyAttributePropertyView<float> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
FCesiumMetadataValueType valueType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Float32,
false);
for (size_t i = 0; i < values.size(); i++) {
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
i);
TestTrue(
"value type",
UCesiumMetadataValueBlueprintLibrary::GetValueType(value) ==
valueType);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumMetadataValueBlueprintLibrary::GetFloat(value, 0),
values[i] * scale + offset);
}
});
It("gets with noData", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
int16_t noData = -1;
classProperty.noData = noData;
std::vector<int16_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
FCesiumMetadataValueType valueType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Int16,
false);
for (size_t i = 0; i < values.size(); i++) {
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
i);
if (values[i] == noData) {
TestTrue(
"value empty",
UCesiumMetadataValueBlueprintLibrary::IsEmpty(value));
} else {
TestTrue(
"value type",
UCesiumMetadataValueBlueprintLibrary::GetValueType(value) ==
valueType);
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumMetadataValueBlueprintLibrary::GetInteger(value, 0),
values[i]);
}
}
});
It("gets with noData / default value", [this]() {
PropertyAttributeProperty propertyAttributeProperty;
ClassProperty classProperty;
classProperty.type = ClassProperty::Type::SCALAR;
classProperty.componentType = ClassProperty::ComponentType::INT16;
int16_t noData = -1;
int16_t defaultValue = 15;
classProperty.noData = noData;
classProperty.defaultProperty = defaultValue;
std::vector<int16_t> values{-1, 2, -3, 4};
std::vector<std::byte> data = GetValuesAsBytes(values);
AccessorView<int16_t> accessorView(
data.data(),
sizeof(int16_t),
0,
values.size());
PropertyAttributePropertyView<int16_t> propertyView(
propertyAttributeProperty,
classProperty,
accessorView);
FCesiumPropertyAttributeProperty property(propertyView);
TestEqual(
"status",
UCesiumPropertyAttributePropertyBlueprintLibrary::
GetPropertyAttributePropertyStatus(property),
ECesiumPropertyAttributePropertyStatus::Valid);
FCesiumMetadataValueType valueType(
ECesiumMetadataType::Scalar,
ECesiumMetadataComponentType::Int16,
false);
for (size_t i = 0; i < values.size(); i++) {
FCesiumMetadataValue value =
UCesiumPropertyAttributePropertyBlueprintLibrary::GetValue(
property,
i);
TestTrue(
"value type",
UCesiumMetadataValueBlueprintLibrary::GetValueType(value) ==
valueType);
if (values[i] == noData) {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumMetadataValueBlueprintLibrary::GetInteger(value, 0),
defaultValue);
} else {
TestEqual(
std::string("value" + std::to_string(i)).c_str(),
UCesiumMetadataValueBlueprintLibrary::GetInteger(value, 0),
values[i]);
}
}
});
});
}
Reference in New Issue View Git Blame Copy Permalink