birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated the image gradient component to use a streaming image asset

Browse Source 
Signed-off-by: Chris Galvan <chgalvan@amazon.com>
This commit is contained in:
Chris Galvan
2022-02-03 12:29:18 -06:00
parent 65e651388c
commit 6322dd5397
10 changed files with 150 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/Atom/Asset/ImageProcessingAtom/Code/Source/BuilderSettings/ImageProcessingDefines.h
-14
View File
@@ -49,20 +49,6 @@ namespace ImageProcessingAtom
static const unsigned int s_MinReduceLevel = 0;
static const unsigned int s_MaxReduceLevel = 5;
static const int s_TotalSupportedImageExtensions = 10;
static const char* s_SupportedImageExtensions[s_TotalSupportedImageExtensions] = {
"*.tif",
"*.tiff",
"*.png",
"*.bmp",
"*.jpg",
"*.jpeg",
"*.tga",
"*.gif",
"*.dds",
"*.exr"
};
enum class RGBWeight : AZ::u32
{
uniform, // uniform weights (1.0, 1.0, 1.0) (default)
Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageBuilderComponent.cpp
+3 -2
View File
@@ -27,6 +27,7 @@
#include <Atom/RPI.Reflect/Asset/AssetHandler.h>
#include <Atom/RPI.Reflect/Image/StreamingImageAssetHandler.h>
#include <Atom/RPI.Reflect/Image/Image.h>
#include <Atom/RPI.Reflect/Image/ImageMipChainAsset.h>
namespace ImageProcessingAtom
@@ -66,9 +67,9 @@ namespace ImageProcessingAtom
AssetBuilderSDK::AssetBuilderDesc builderDescriptor;
builderDescriptor.m_name = "Atom Image Builder";
for (int i = 0; i < s_TotalSupportedImageExtensions; i++)
for (int i = 0; i < AZ::RPI::s_TotalSupportedImageExtensions; i++)
{
builderDescriptor.m_patterns.push_back(AssetBuilderSDK::AssetBuilderPattern(s_SupportedImageExtensions[i], AssetBuilderSDK::AssetBuilderPattern::PatternType::Wildcard));
builderDescriptor.m_patterns.push_back(AssetBuilderSDK::AssetBuilderPattern(AZ::RPI::s_SupportedImageExtensions[i], AssetBuilderSDK::AssetBuilderPattern::PatternType::Wildcard));
}
builderDescriptor.m_busId = azrtti_typeid<ImageBuilderWorker>();
Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageProcessingSystemComponent.cpp
+3 -2
View File
@@ -7,6 +7,7 @@
*/
#include <Atom/RPI.Reflect/Image/Image.h>
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
#include <AzCore/Component/ComponentApplicationBus.h>
@@ -223,9 +224,9 @@ namespace ImageProcessingAtom
{
AZStd::string targetExtension = entry->GetExtension();
for (int i = 0; i < s_TotalSupportedImageExtensions; i++)
for (int i = 0; i < AZ::RPI::s_TotalSupportedImageExtensions; i++)
{
if (AZStd::wildcard_match(s_SupportedImageExtensions[i], targetExtension.c_str()))
if (AZStd::wildcard_match(AZ::RPI::s_SupportedImageExtensions[i], targetExtension.c_str()))
{
return true;
}
Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/Image/Image.h
+14
View File
@@ -22,6 +22,20 @@ namespace AZ
{
class ImageAsset;
static const int s_TotalSupportedImageExtensions = 10;
static const char* s_SupportedImageExtensions[s_TotalSupportedImageExtensions] = {
"*.tif",
"*.tiff",
"*.png",
"*.bmp",
"*.jpg",
"*.jpeg",
"*.tga",
"*.gif",
"*.dds",
"*.exr"
};
//! A base class for images providing access to common image information.
class Image
: public Data::InstanceData
Gems/Atom/RPI/Code/Source/RPI.Public/RPIUtils.cpp
+5 -7
View File
@@ -133,7 +133,8 @@ namespace AZ
case AZ::RHI::Format::R16G16_UNORM:
case AZ::RHI::Format::R16G16B16A16_UNORM:
{
return mem[index] / static_cast<float>(std::numeric_limits<AZ::u16>::max());
auto actualMem = reinterpret_cast<const AZ::u16*>(mem);
return actualMem[index] / static_cast<float>(std::numeric_limits<AZ::u16>::max());
}
case AZ::RHI::Format::R16_SNORM:
case AZ::RHI::Format::R16G16_SNORM:
@@ -480,14 +481,13 @@ namespace AZ
const AZ::RHI::ImageDescriptor imageDescriptor = imageAsset->GetImageDescriptor();
auto width = imageDescriptor.m_size.m_width;
const uint32_t numComponents = AZ::RHI::GetFormatComponentCount(imageDescriptor.m_format);
const uint32_t pixelSize = AZ::RHI::GetFormatSize(imageDescriptor.m_format) / numComponents;
size_t outValuesIndex = 0;
for (uint32_t y = topLeft.second; y < bottomRight.second; ++y)
{
for (uint32_t x = topLeft.first; x < bottomRight.first; ++x)
{
size_t imageDataIndex = (y * width + x) * pixelSize + componentIndex;
size_t imageDataIndex = (y * width + x) * numComponents + componentIndex;
auto& outValue = outValues[outValuesIndex++];
outValue = Internal::RetrieveFloatValue(imageData.data(), imageDataIndex, imageDescriptor.m_format);
@@ -513,14 +513,13 @@ namespace AZ
const AZ::RHI::ImageDescriptor imageDescriptor = imageAsset->GetImageDescriptor();
auto width = imageDescriptor.m_size.m_width;
const uint32_t numComponents = AZ::RHI::GetFormatComponentCount(imageDescriptor.m_format);
const uint32_t pixelSize = AZ::RHI::GetFormatSize(imageDescriptor.m_format) / numComponents;
size_t outValuesIndex = 0;
for (uint32_t y = topLeft.second; y < bottomRight.second; ++y)
{
for (uint32_t x = topLeft.first; x < bottomRight.first; ++x)
{
size_t imageDataIndex = (y * width + x) * pixelSize + componentIndex;
size_t imageDataIndex = (y * width + x) * numComponents + componentIndex;
auto& outValue = outValues[outValuesIndex++];
outValue = Internal::RetrieveUintValue(imageData.data(), imageDataIndex, imageDescriptor.m_format);
@@ -546,14 +545,13 @@ namespace AZ
const AZ::RHI::ImageDescriptor imageDescriptor = imageAsset->GetImageDescriptor();
auto width = imageDescriptor.m_size.m_width;
const uint32_t numComponents = AZ::RHI::GetFormatComponentCount(imageDescriptor.m_format);
const uint32_t pixelSize = AZ::RHI::GetFormatSize(imageDescriptor.m_format) / numComponents;
size_t outValuesIndex = 0;
for (uint32_t y = topLeft.second; y < bottomRight.second; ++y)
{
for (uint32_t x = topLeft.first; x < bottomRight.first; ++x)
{
size_t imageDataIndex = (y * width + x) * pixelSize + componentIndex;
size_t imageDataIndex = (y * width + x) * numComponents + componentIndex;
auto& outValue = outValues[outValuesIndex++];
outValue = Internal::RetrieveIntValue(imageData.data(), imageDataIndex, imageDescriptor.m_format);
Gems/GradientSignal/Code/CMakeLists.txt
+3
View File
@@ -17,9 +17,12 @@ ly_add_target(
PUBLIC
Include
BUILD_DEPENDENCIES
PRIVATE
AZ::AtomCore
PUBLIC
AZ::AzCore
AZ::AzFramework
Gem::Atom_RPI.Public
Gem::SurfaceData
Gem::ImageProcessingAtom.Headers
Gem::LmbrCentral
Gems/GradientSignal/Code/Include/GradientSignal/Components/ImageGradientComponent.h
+17 -1
View File
@@ -8,8 +8,11 @@
#pragma once
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
#include <AzCore/Asset/AssetCommon.h>
#include <AzCore/Component/Component.h>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/Json/RegistrationContext.h>
#include <GradientSignal/Ebuses/GradientRequestBus.h>
#include <GradientSignal/Ebuses/GradientTransformRequestBus.h>
#include <GradientSignal/Ebuses/ImageGradientRequestBus.h>
@@ -25,6 +28,19 @@ namespace LmbrCentral
namespace GradientSignal
{
// Custom JSON serializer for ImageGradientConfig to handle version conversion
class JsonImageGradientConfigSerializer
: public AZ::BaseJsonSerializer
{
public:
AZ_RTTI(GradientSignal::JsonImageGradientConfigSerializer, "{C5B982C8-2E81-45C3-8932-B6F54B28F493}", AZ::BaseJsonSerializer);
AZ_CLASS_ALLOCATOR_DECL;
AZ::JsonSerializationResult::Result Load(
void* outputValue, const AZ::Uuid& outputValueTypeId, const rapidjson::Value& inputValue,
AZ::JsonDeserializerContext& context) override;
};
class ImageGradientConfig
: public AZ::ComponentConfig
{
@@ -32,7 +48,7 @@ namespace GradientSignal
AZ_CLASS_ALLOCATOR(ImageGradientConfig, AZ::SystemAllocator, 0);
AZ_RTTI(ImageGradientConfig, "{1BDB5DA4-A4A8-452B-BE6D-6BD451D4E7CD}", AZ::ComponentConfig);
static void Reflect(AZ::ReflectContext* context);
AZ::Data::Asset<ImageAsset> m_imageAsset = { AZ::Data::AssetLoadBehavior::QueueLoad };
AZ::Data::Asset<AZ::RPI::StreamingImageAsset> m_imageAsset = { AZ::Data::AssetLoadBehavior::QueueLoad };
float m_tilingX = 1.0f;
float m_tilingY = 1.0f;
};
Gems/GradientSignal/Code/Include/GradientSignal/ImageAsset.h
+2 -1
View File
@@ -12,6 +12,7 @@
#include <AzCore/RTTI/ReflectContext.h>
#include <AzFramework/Asset/GenericAssetHandler.h>
#include <Atom/ImageProcessing/PixelFormats.h>
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
namespace AZ
{
@@ -61,6 +62,6 @@ namespace GradientSignal
}
};
float GetValueFromImageAsset(const AZ::Data::Asset<ImageAsset>& imageAsset, const AZ::Vector3& uvw, float tilingX, float tilingY, float defaultValue);
float GetValueFromImageAsset(const AZ::Data::Asset<AZ::RPI::StreamingImageAsset>& imageAsset, const AZ::Vector3& uvw, float tilingX, float tilingY, float defaultValue);
} // namespace GradientSignal
Gems/GradientSignal/Code/Source/Components/ImageGradientComponent.cpp
+90 -2
View File
@@ -7,6 +7,7 @@
*/
#include <GradientSignal/Components/ImageGradientComponent.h>
#include <Atom/RPI.Reflect/Image/Image.h>
#include <AzCore/Asset/AssetManager.h>
#include <AzCore/Asset/AssetSerializer.h>
#include <AzCore/Debug/Profiler.h>
@@ -18,13 +19,100 @@
namespace GradientSignal
{
AZ::JsonSerializationResult::Result JsonImageGradientConfigSerializer::Load(
void* outputValue, [[maybe_unused]] const AZ::Uuid& outputValueTypeId,
const rapidjson::Value& inputValue, AZ::JsonDeserializerContext& context)
{
namespace JSR = AZ::JsonSerializationResult;
auto configInstance = reinterpret_cast<ImageGradientConfig*>(outputValue);
AZ_Assert(configInstance, "Output value for JsonImageGradientConfigSerializer can't be null.");
JSR::ResultCode result(JSR::Tasks::ReadField);
rapidjson::Value::ConstMemberIterator itr = inputValue.FindMember("ImageAsset");
if (itr != inputValue.MemberEnd())
{
// Version 1 stored a custom GradientSignal::ImageAsset as the image asset.
// In Version 2, we changed the image asset to use the generic AZ::RPI::StreamingImageAsset,
// so they are both AZ::Data::Asset but reference different types.
// Using the assetHint, which will be something like "my_test_image.gradimage",
// we need to find the valid streaming image asset product from the same source,
// which will be something like "my_test_image.png.streamingimage"
AZStd::string assetHint;
AZ::Data::AssetId fixedAssetId;
auto it = itr->value.FindMember("assetHint");
if (it != itr->value.MemberEnd())
{
AZ::ScopedContextPath subPath(context, "assetHint");
result.Combine(ContinueLoading(&assetHint, azrtti_typeid<AZStd::string>(), it->value, context));
if (assetHint.ends_with(".gradimage"))
{
// We don't know what image format the original source was, so we need to loop through
// all the supported image extensions to check if they have a valid corresponding
// streaming image asset
for (int i = 0; i < AZ::RPI::s_TotalSupportedImageExtensions; i++)
{
AZStd::string imageExtension(AZ::RPI::s_SupportedImageExtensions[i]);
// The image extensions are stored with a wildcard (e.g. *.png) so we need to strip that off first
AZ::StringFunc::Replace(imageExtension, "*", "");
// Form potential streaming image path (e.g. my_test_image.png.streamingimage)
AZStd::string potentialStreamingImagePath(assetHint);
AZ::StringFunc::Replace(potentialStreamingImagePath, ".gradimage", "");
potentialStreamingImagePath += imageExtension + ".streamingimage";
// Check if there is a valid streaming image asset for this path
AZ::Data::AssetCatalogRequestBus::BroadcastResult(fixedAssetId, &AZ::Data::AssetCatalogRequestBus::Events::GetAssetIdByPath, potentialStreamingImagePath.c_str(), azrtti_typeid<AZ::Data::Asset<AZ::RPI::StreamingImageAsset>>(), false);
if (fixedAssetId.IsValid())
{
break;
}
}
}
}
// Replace the old gradimage with new AssetId for streaming image asset (if we needed to replace)
if (fixedAssetId.IsValid())
{
configInstance->m_imageAsset = AZ::Data::AssetManager::Instance().GetAsset<AZ::RPI::StreamingImageAsset>(fixedAssetId, AZ::Data::AssetLoadBehavior::QueueLoad);
}
// Otherwise, this was already a streaming image asset, so just load it like normal
else
{
result.Combine(ContinueLoadingFromJsonObjectField(
&configInstance->m_imageAsset, azrtti_typeid<decltype(configInstance->m_imageAsset)>(), inputValue, "ImageAsset", context));
}
}
result.Combine(ContinueLoadingFromJsonObjectField(
&configInstance->m_tilingX, azrtti_typeid<decltype(configInstance->m_tilingX)>(), inputValue, "TilingX", context));
result.Combine(ContinueLoadingFromJsonObjectField(
&configInstance->m_tilingY, azrtti_typeid<decltype(configInstance->m_tilingY)>(), inputValue, "TilingY", context));
return context.Report(result,
result.GetProcessing() != JSR::Processing::Halted ?
"Successfully loaded ImageGradientConfig information." :
"Failed to load ImageGradientConfig information.");
}
AZ_CLASS_ALLOCATOR_IMPL(JsonImageGradientConfigSerializer, AZ::SystemAllocator, 0);
void ImageGradientConfig::Reflect(AZ::ReflectContext* context)
{
if (auto jsonContext = azrtti_cast<AZ::JsonRegistrationContext*>(context))
{
jsonContext->Serializer<JsonImageGradientConfigSerializer>()->HandlesType<ImageGradientConfig>();
}
AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
if (serialize)
{
serialize->Class<ImageGradientConfig, AZ::ComponentConfig>()
->Version(1)
->Version(2)
->Field("ImageAsset", &ImageGradientConfig::m_imageAsset)
->Field("TilingX", &ImageGradientConfig::m_tilingX)
->Field("TilingY", &ImageGradientConfig::m_tilingY)
@@ -265,7 +353,7 @@ namespace GradientSignal
{
AZStd::unique_lock<decltype(m_imageMutex)> imageLock(m_imageMutex);
m_configuration.m_imageAsset = AZ::Data::AssetManager::Instance().FindOrCreateAsset(assetId, azrtti_typeid<ImageAsset>(), m_configuration.m_imageAsset.GetAutoLoadBehavior());
m_configuration.m_imageAsset = AZ::Data::AssetManager::Instance().FindOrCreateAsset(assetId, azrtti_typeid<AZ::RPI::StreamingImageAsset>(), m_configuration.m_imageAsset.GetAutoLoadBehavior());
}
SetupDependencies();
Gems/GradientSignal/Code/Source/ImageAsset.cpp
+13 -14
View File
@@ -15,6 +15,7 @@
#include <AzCore/Debug/Profiler.h>
#include <Atom/ImageProcessing/PixelFormats.h>
#include <Atom/RPI.Public/RPIUtils.h>
#include <GradientSignal/Util.h>
#include <numeric>
@@ -152,17 +153,15 @@ namespace GradientSignal
return true;
}
float GetValueFromImageAsset(const AZ::Data::Asset<ImageAsset>& imageAsset, const AZ::Vector3& uvw, float tilingX, float tilingY, float defaultValue)
float GetValueFromImageAsset(const AZ::Data::Asset<AZ::RPI::StreamingImageAsset>& imageAsset, const AZ::Vector3& uvw, float tilingX, float tilingY, float defaultValue)
{
if (imageAsset.IsReady())
{
const auto& image = imageAsset.Get();
AZStd::size_t imageSize = image->m_imageWidth * image->m_imageHeight *
static_cast<AZ::u32>(image->m_bytesPerPixel);
if (image->m_imageWidth > 0 &&
image->m_imageHeight > 0 &&
image->m_imageData.size() == imageSize)
auto imageDescriptor = imageAsset->GetImageDescriptor();
auto width = imageDescriptor.m_size.m_width;
auto height = imageDescriptor.m_size.m_height;
if (width > 0 && height > 0)
{
// When "rasterizing" from uvs, a range of 0-1 has slightly different meanings depending on the sampler state.
// For repeating states (Unbounded/None, Repeat), a uv value of 1 should wrap around back to our 0th pixel.
@@ -185,8 +184,8 @@ namespace GradientSignal
// A 16x16 pixel image and tilingX = tilingY = 1 maps the uv range of 0-1 to 0-16 pixels.
// A 16x16 pixel image and tilingX = tilingY = 1.5 maps the uv range of 0-1 to 0-24 pixels.
const AZ::Vector3 tiledDimensions((image->m_imageWidth * tilingX),
(image->m_imageHeight * tilingY),
const AZ::Vector3 tiledDimensions((width * tilingX),
(height * tilingY),
0.0f);
// Convert from uv space back to pixel space
@@ -195,13 +194,13 @@ namespace GradientSignal
// UVs outside the 0-1 range are treated as infinitely tiling, so that we behave the same as the
// other gradient generators. As mentioned above, if clamping is desired, we expect it to be applied
// outside of this function.
size_t x = static_cast<size_t>(pixelLookup.GetX()) % image->m_imageWidth;
size_t y = static_cast<size_t>(pixelLookup.GetY()) % image->m_imageHeight;
auto x = aznumeric_cast<AZ::u32>(pixelLookup.GetX()) % width;
auto y = aznumeric_cast<AZ::u32>(pixelLookup.GetY()) % height;
// Flip the y because images are stored in reverse of our world axes
size_t index = ((image->m_imageHeight - 1) - y) * image->m_imageWidth + x;
y = (height - 1) - y;
return RetrieveValue(image->m_imageData.data(), index, image->m_imageFormat);
return AZ::RPI::GetSubImagePixelValue<float>(imageAsset, x, y);
}
}