Files
o3de/Gems/Vegetation/Code/Source/Components/PositionModifierComponent.cpp
T
Mike Balfour d9ba0af645 SurfacePoint data structure encapsulations (#7413)
* First pass at encapsulating SurfacePointList.
The biggest challenge in optimizing SurfacePointList(s) usage is the overall memory management associated with it. There are M surface points with N surface mask entries created for every input point, which leads to a lot of container reallocation and memory shuffling when processing multiple input points. By encapsulating the list, it should become easier to preallocate the entries, as well as keep "helper data" around for managing the bookkeeping to associate the input points with the output points.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Small fixes and TODO reminders.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Encapsulate surface point creation and separate EnumeratePoints out from modifications.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Start removing SurfacePoint from the exposed API.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Changed SurfacePointList to split out the surface point storage to allow for span<> usage over time.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Removed entity id

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Removed SurfacePoint from SurfaceData, changed all remaining uses to AzFramework::SurfaceData::SurfacePoint.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Encapsulated SurfaceTagWeightMap and renamed to SurfaceTagWeights.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Fixed make file.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Better commenting and parameter naming.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>

* Renamed methods to be more descriptive.

Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com>
2022-02-04 11:27:59 -06:00

427 lines
21 KiB
C++

/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include "PositionModifierComponent.h"
#include <AzCore/Component/Entity.h>
#include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/std/sort.h>
#include <Vegetation/Descriptor.h>
#include <GradientSignal/Ebuses/GradientRequestBus.h>
#include <Vegetation/InstanceData.h>
#include <SurfaceData/SurfaceDataSystemRequestBus.h>
#include <AzCore/Debug/Profiler.h>
namespace Vegetation
{
namespace PositionModifierUtil
{
static bool UpdateVersion(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
{
if (classElement.GetVersion() < 1)
{
AZ::Vector3 rangeMin(-0.3f, -0.3f, 0.0f);
if (classElement.GetChildData(AZ_CRC("RangeMin", 0xedb80851), rangeMin))
{
classElement.RemoveElementByName(AZ_CRC("RangeMin", 0xedb80851));
classElement.AddElementWithData(context, "RangeMinX", (float)rangeMin.GetX());
classElement.AddElementWithData(context, "RangeMinY", (float)rangeMin.GetY());
classElement.AddElementWithData(context, "RangeMinZ", (float)rangeMin.GetZ());
}
AZ::Vector3 rangeMax(0.3f, 0.3f, 0.0f);
if (classElement.GetChildData(AZ_CRC("RangeMax", 0xd1b53708), rangeMax))
{
classElement.RemoveElementByName(AZ_CRC("RangeMax", 0xd1b53708));
classElement.AddElementWithData(context, "RangeMaxX", (float)rangeMax.GetX());
classElement.AddElementWithData(context, "RangeMaxY", (float)rangeMax.GetY());
classElement.AddElementWithData(context, "RangeMaxZ", (float)rangeMax.GetZ());
}
}
return true;
}
}
void PositionModifierConfig::Reflect(AZ::ReflectContext* context)
{
AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
if (serialize)
{
serialize->Class<PositionModifierConfig, AZ::ComponentConfig>()
->Version(1, &PositionModifierUtil::UpdateVersion)
->Field("AllowOverrides", &PositionModifierConfig::m_allowOverrides)
->Field("AutoSnapToSurface", &PositionModifierConfig::m_autoSnapToSurface)
->Field("SurfacesToSnapTo", &PositionModifierConfig::m_surfaceTagsToSnapTo)
->Field("RangeMinX", &PositionModifierConfig::m_rangeMinX)
->Field("RangeMaxX", &PositionModifierConfig::m_rangeMaxX)
->Field("GradientX", &PositionModifierConfig::m_gradientSamplerX)
->Field("RangeMinY", &PositionModifierConfig::m_rangeMinY)
->Field("RangeMaxY", &PositionModifierConfig::m_rangeMaxY)
->Field("GradientY", &PositionModifierConfig::m_gradientSamplerY)
->Field("RangeMinZ", &PositionModifierConfig::m_rangeMinZ)
->Field("RangeMaxZ", &PositionModifierConfig::m_rangeMaxZ)
->Field("GradientZ", &PositionModifierConfig::m_gradientSamplerZ)
;
AZ::EditContext* edit = serialize->GetEditContext();
if (edit)
{
edit->Class<PositionModifierConfig>(
"Vegetation Position Modifier", "")
->ClassElement(AZ::Edit::ClassElements::EditorData, "")
->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
->Attribute(AZ::Edit::Attributes::AutoExpand, true)
->DataElement(AZ::Edit::UIHandlers::CheckBox, &PositionModifierConfig::m_allowOverrides, "Allow Per-Item Overrides", "Allow per-descriptor parameters to override component parameters.")
->DataElement(0, &PositionModifierConfig::m_autoSnapToSurface, "Auto Snap To Surface", "Automatically snap to the surface closest to the new position using Surface Tags To Snap To plus the initial surface tags.")
->DataElement(0, &PositionModifierConfig::m_surfaceTagsToSnapTo, "Surface Tags To Snap To", "Additional surface tags to snap to if auto snap is enabled.")
->ClassElement(AZ::Edit::ClassElements::Group, "Position X")
->Attribute(AZ::Edit::Attributes::AutoExpand, true)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMinX, "Range Min", "Minimum position offset on X axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMaxX, "Range Max", "Maximum position offset on X axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(0, &PositionModifierConfig::m_gradientSamplerX, "Gradient", "Gradient used as blend factor to lerp between ranges on X axis.")
->ClassElement(AZ::Edit::ClassElements::Group, "Position Y")
->Attribute(AZ::Edit::Attributes::AutoExpand, true)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMinY, "Range Min", "Minimum position offset on Y axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMaxY, "Range Max", "Maximum position offset on Y axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(0, &PositionModifierConfig::m_gradientSamplerY, "Gradient", "Gradient used as blend factor to lerp between ranges on Y axis.")
->ClassElement(AZ::Edit::ClassElements::Group, "Position Z")
->Attribute(AZ::Edit::Attributes::AutoExpand, false)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMinZ, "Range Min", "Minimum position offset on Z axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(AZ::Edit::UIHandlers::Slider, &PositionModifierConfig::m_rangeMaxZ, "Range Max", "Maximum position offset on Z axis.")
->Attribute(AZ::Edit::Attributes::Min, std::numeric_limits<float>::lowest())
->Attribute(AZ::Edit::Attributes::Max, std::numeric_limits<float>::max())
->Attribute(AZ::Edit::Attributes::SoftMin, -2.0f)
->Attribute(AZ::Edit::Attributes::SoftMax, 2.0f)
->DataElement(0, &PositionModifierConfig::m_gradientSamplerZ, "Gradient", "Gradient used as blend factor to lerp between ranges on Z axis.")
;
}
}
if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
{
behaviorContext->Class<PositionModifierConfig>()
->Attribute(AZ::Script::Attributes::Category, "Vegetation")
->Constructor()
->Property("allowOverrides", BehaviorValueProperty(&PositionModifierConfig::m_allowOverrides))
->Property("rangeMinX", BehaviorValueProperty(&PositionModifierConfig::m_rangeMinX))
->Property("rangeMaxX", BehaviorValueProperty(&PositionModifierConfig::m_rangeMaxX))
->Property("gradientSamplerX", BehaviorValueProperty(&PositionModifierConfig::m_gradientSamplerX))
->Property("rangeMinY", BehaviorValueProperty(&PositionModifierConfig::m_rangeMinY))
->Property("rangeMaxY", BehaviorValueProperty(&PositionModifierConfig::m_rangeMaxY))
->Property("gradientSamplerY", BehaviorValueProperty(&PositionModifierConfig::m_gradientSamplerY))
->Property("rangeMinZ", BehaviorValueProperty(&PositionModifierConfig::m_rangeMinZ))
->Property("rangeMaxZ", BehaviorValueProperty(&PositionModifierConfig::m_rangeMaxZ))
->Property("gradientSamplerZ", BehaviorValueProperty(&PositionModifierConfig::m_gradientSamplerZ))
->Method("GetNumTags", &PositionModifierConfig::GetNumTags)
->Method("GetTag", &PositionModifierConfig::GetTag)
->Method("RemoveTag", &PositionModifierConfig::RemoveTag)
->Method("AddTag", &PositionModifierConfig::AddTag)
;
}
}
size_t PositionModifierConfig::GetNumTags() const
{
return m_surfaceTagsToSnapTo.size();
}
AZ::Crc32 PositionModifierConfig::GetTag(int tagIndex) const
{
if (tagIndex < m_surfaceTagsToSnapTo.size())
{
return m_surfaceTagsToSnapTo[tagIndex];
}
return AZ::Crc32();
}
void PositionModifierConfig::RemoveTag(int tagIndex)
{
if (tagIndex < m_surfaceTagsToSnapTo.size())
{
m_surfaceTagsToSnapTo.erase(m_surfaceTagsToSnapTo.begin() + tagIndex);
}
}
void PositionModifierConfig::AddTag(AZStd::string tag)
{
m_surfaceTagsToSnapTo.push_back(SurfaceData::SurfaceTag(tag));
}
void PositionModifierComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
{
services.push_back(AZ_CRC("VegetationModifierService", 0xc551fca6));
services.push_back(AZ_CRC("VegetationPositionModifierService", 0xe7d7293e));
}
void PositionModifierComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
{
services.push_back(AZ_CRC("VegetationPositionModifierService", 0xe7d7293e));
}
void PositionModifierComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
{
services.push_back(AZ_CRC("VegetationAreaService", 0x6a859504));
}
void PositionModifierComponent::Reflect(AZ::ReflectContext* context)
{
PositionModifierConfig::Reflect(context);
AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
if (serialize)
{
serialize->Class<PositionModifierComponent, AZ::Component>()
->Version(0)
->Field("Configuration", &PositionModifierComponent::m_configuration)
;
}
if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
{
behaviorContext->Constant("PositionModifierComponentTypeId", BehaviorConstant(PositionModifierComponentTypeId));
behaviorContext->Class<PositionModifierComponent>()->RequestBus("PositionModifierRequestBus");
behaviorContext->EBus<PositionModifierRequestBus>("PositionModifierRequestBus")
->Attribute(AZ::Script::Attributes::Category, "Vegetation")
->Event("GetAllowOverrides", &PositionModifierRequestBus::Events::GetAllowOverrides)
->Event("SetAllowOverrides", &PositionModifierRequestBus::Events::SetAllowOverrides)
->VirtualProperty("AllowOverrides", "GetAllowOverrides", "SetAllowOverrides")
->Event("GetRangeMin", &PositionModifierRequestBus::Events::GetRangeMin)
->Event("SetRangeMin", &PositionModifierRequestBus::Events::SetRangeMin)
->VirtualProperty("RangeMin", "GetRangeMin", "SetRangeMin")
->Event("GetRangeMax", &PositionModifierRequestBus::Events::GetRangeMax)
->Event("SetRangeMax", &PositionModifierRequestBus::Events::SetRangeMax)
->VirtualProperty("RangeMax", "GetRangeMax", "SetRangeMax")
->Event("GetGradientSamplerX", &PositionModifierRequestBus::Events::GetGradientSamplerX)
->Event("GetGradientSamplerY", &PositionModifierRequestBus::Events::GetGradientSamplerY)
->Event("GetGradientSamplerZ", &PositionModifierRequestBus::Events::GetGradientSamplerZ)
->Event("GetNumTags", &PositionModifierRequestBus::Events::GetNumTags)
->Event("GetTag", &PositionModifierRequestBus::Events::GetTag)
->Event("RemoveTag", &PositionModifierRequestBus::Events::RemoveTag)
->Event("AddTag", &PositionModifierRequestBus::Events::AddTag)
;
}
}
PositionModifierComponent::PositionModifierComponent(const PositionModifierConfig& configuration)
: m_configuration(configuration)
{
}
void PositionModifierComponent::Activate()
{
m_dependencyMonitor.Reset();
m_dependencyMonitor.ConnectOwner(GetEntityId());
m_dependencyMonitor.ConnectDependencies({
m_configuration.m_gradientSamplerX.m_gradientId,
m_configuration.m_gradientSamplerY.m_gradientId,
m_configuration.m_gradientSamplerZ.m_gradientId });
ModifierRequestBus::Handler::BusConnect(GetEntityId());
PositionModifierRequestBus::Handler::BusConnect(GetEntityId());
}
void PositionModifierComponent::Deactivate()
{
m_dependencyMonitor.Reset();
ModifierRequestBus::Handler::BusDisconnect();
PositionModifierRequestBus::Handler::BusDisconnect();
}
bool PositionModifierComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
{
if (auto config = azrtti_cast<const PositionModifierConfig*>(baseConfig))
{
m_configuration = *config;
return true;
}
return false;
}
bool PositionModifierComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
{
if (auto config = azrtti_cast<PositionModifierConfig*>(outBaseConfig))
{
*config = m_configuration;
return true;
}
return false;
}
void PositionModifierComponent::Execute(InstanceData& instanceData) const
{
AZ_PROFILE_FUNCTION(Entity);
const GradientSignal::GradientSampleParams sampleParams(instanceData.m_position);
float factorX = m_configuration.m_gradientSamplerX.GetValue(sampleParams);
float factorY = m_configuration.m_gradientSamplerY.GetValue(sampleParams);
float factorZ = m_configuration.m_gradientSamplerZ.GetValue(sampleParams);
const bool useOverrides = m_configuration.m_allowOverrides && instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->m_positionOverrideEnabled;
const AZ::Vector3& min = useOverrides ? instanceData.m_descriptorPtr->GetPositionMin() : GetRangeMin();
const AZ::Vector3& max = useOverrides ? instanceData.m_descriptorPtr->GetPositionMax() : GetRangeMax();
const AZ::Vector3 delta = min + AZ::Vector3(
(max.GetX() - min.GetX()) * factorX,
(max.GetY() - min.GetY()) * factorY,
(max.GetZ() - min.GetZ()) * factorZ);
const AZ::Vector3 deltaXY(delta.GetX(), delta.GetY(), 0.0f);
instanceData.m_position += deltaXY;
//auto snapping to surface if change occurred on XY axis
if (m_configuration.m_autoSnapToSurface && !deltaXY.IsClose(AZ::Vector3::CreateZero()))
{
//get the combined set of masks to consider for snapping
m_surfaceTagsToSnapToCombined.clear();
m_surfaceTagsToSnapToCombined.reserve(
m_configuration.m_surfaceTagsToSnapTo.size() +
instanceData.m_masks.GetSize());
m_surfaceTagsToSnapToCombined.insert(m_surfaceTagsToSnapToCombined.end(),
m_configuration.m_surfaceTagsToSnapTo.begin(), m_configuration.m_surfaceTagsToSnapTo.end());
instanceData.m_masks.EnumerateWeights(
[this](AZ::Crc32 surfaceType, [[maybe_unused]] float weight)
{
m_surfaceTagsToSnapToCombined.push_back(surfaceType);
return true;
});
//get the intersection data at the new position
m_points.Clear();
SurfaceData::SurfaceDataSystemRequestBus::Broadcast(&SurfaceData::SurfaceDataSystemRequestBus::Events::GetSurfacePoints, instanceData.m_position, m_surfaceTagsToSnapToCombined, m_points);
// Get the point with the closest distance from the new position in case there are multiple intersections at different or
// unrelated heights
float closestPointDistanceSq = AZStd::numeric_limits<float>::max();
AZ::Vector3 originalInstanceDataPosition = instanceData.m_position;
m_points.EnumeratePoints(
[&instanceData, originalInstanceDataPosition, &closestPointDistanceSq](
const AZ::Vector3& position, const AZ::Vector3& normal, const SurfaceData::SurfaceTagWeights& masks) -> bool
{
float distanceSq = position.GetDistanceSq(originalInstanceDataPosition);
if (distanceSq < closestPointDistanceSq)
{
instanceData.m_position = position;
instanceData.m_normal = normal;
instanceData.m_masks = masks;
closestPointDistanceSq = distanceSq;
}
return true;
});
}
instanceData.m_position.SetZ(instanceData.m_position.GetZ() + delta.GetZ());
}
ModifierStage PositionModifierComponent::GetModifierStage() const
{
return ModifierStage::PreProcess;
}
bool PositionModifierComponent::GetAllowOverrides() const
{
return m_configuration.m_allowOverrides;
}
void PositionModifierComponent::SetAllowOverrides(bool value)
{
m_configuration.m_allowOverrides = value;
LmbrCentral::DependencyNotificationBus::Event(GetEntityId(), &LmbrCentral::DependencyNotificationBus::Events::OnCompositionChanged);
}
AZ::Vector3 PositionModifierComponent::GetRangeMin() const
{
return AZ::Vector3(m_configuration.m_rangeMinX, m_configuration.m_rangeMinY, m_configuration.m_rangeMinZ);
}
void PositionModifierComponent::SetRangeMin(AZ::Vector3 rangeMin)
{
m_configuration.m_rangeMinX = rangeMin.GetX();
m_configuration.m_rangeMinY = rangeMin.GetY();
m_configuration.m_rangeMinZ = rangeMin.GetZ();
LmbrCentral::DependencyNotificationBus::Event(GetEntityId(), &LmbrCentral::DependencyNotificationBus::Events::OnCompositionChanged);
}
AZ::Vector3 PositionModifierComponent::GetRangeMax() const
{
return AZ::Vector3(m_configuration.m_rangeMaxX, m_configuration.m_rangeMaxY, m_configuration.m_rangeMaxZ);
}
void PositionModifierComponent::SetRangeMax(AZ::Vector3 rangeMax)
{
m_configuration.m_rangeMaxX = rangeMax.GetX();
m_configuration.m_rangeMaxY = rangeMax.GetY();
m_configuration.m_rangeMaxZ = rangeMax.GetZ();
LmbrCentral::DependencyNotificationBus::Event(GetEntityId(), &LmbrCentral::DependencyNotificationBus::Events::OnCompositionChanged);
}
GradientSignal::GradientSampler& PositionModifierComponent::GetGradientSamplerX()
{
return m_configuration.m_gradientSamplerX;
}
GradientSignal::GradientSampler& PositionModifierComponent::GetGradientSamplerY()
{
return m_configuration.m_gradientSamplerY;
}
GradientSignal::GradientSampler& PositionModifierComponent::GetGradientSamplerZ()
{
return m_configuration.m_gradientSamplerZ;
}
size_t PositionModifierComponent::GetNumTags() const
{
return m_configuration.GetNumTags();
}
AZ::Crc32 PositionModifierComponent::GetTag(int tagIndex) const
{
return m_configuration.GetTag(tagIndex);
}
void PositionModifierComponent::RemoveTag(int tagIndex)
{
m_configuration.RemoveTag(tagIndex);
LmbrCentral::DependencyNotificationBus::Event(GetEntityId(), &LmbrCentral::DependencyNotificationBus::Events::OnCompositionChanged);
}
void PositionModifierComponent::AddTag(AZStd::string tag)
{
m_configuration.AddTag(tag);
LmbrCentral::DependencyNotificationBus::Event(GetEntityId(), &LmbrCentral::DependencyNotificationBus::Events::OnCompositionChanged);
}
}