GoaLitiuM/FlaxEngine
1
0
Fork 0
Code Issues Pull Requests Actions 7 Packages Projects Releases Wiki Activity

Add distance-based and frustum-based culling to cloth

Browse Source
This commit is contained in:
Wojtek Figat
2023-07-17 11:16:01 +02:00
parent de8613e223
commit 1af076f180
4 changed files with 130 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Engine/Level/Actors/AnimatedModel.cpp
View File

@@ -881,7 +881,7 @@ void AnimatedModel::Draw(RenderContext& renderContext)
Matrix::Transformation(_transform.Scale, _transform.Orientation, translation, world);
GEOMETRY_DRAW_STATE_EVENT_BEGIN(_drawState, world);
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.Position + renderContext.View.Origin));
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.WorldPosition));
if (_skinningData.IsReady())
{
// Flush skinning data with GPU
@@ -924,7 +924,7 @@ void AnimatedModel::Draw(RenderContextBatch& renderContextBatch)
Matrix::Transformation(_transform.Scale, _transform.Orientation, translation, world);
GEOMETRY_DRAW_STATE_EVENT_BEGIN(_drawState, world);
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.Position + renderContext.View.Origin));
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.WorldPosition));
if (_skinningData.IsReady())
{
// Flush skinning data with GPU

63
Source/Engine/Physics/Actors/Cloth.cpp
View File

@@ -3,6 +3,7 @@
#include "Cloth.h"
#include "Engine/Core/Log.h"
#include "Engine/Core/Math/Ray.h"
#include "Engine/Graphics/RenderTask.h"
#include "Engine/Graphics/RenderTools.h"
#include "Engine/Graphics/Models/MeshBase.h"
#include "Engine/Graphics/Models/MeshDeformation.h"
@@ -21,6 +22,9 @@ Cloth::Cloth(const SpawnParams& params)
{
// Use the first mesh by default
_mesh.LODIndex = _mesh.MeshIndex = 0;
// Register for drawing to handle culling and distance LOD
_drawCategory = SceneRendering::SceneDrawAsync;
}
ModelInstanceActor::MeshReference Cloth::GetMesh() const
@@ -441,6 +445,7 @@ void Cloth::EndPlay()
void Cloth::OnEnable()
{
#if USE_EDITOR
GetSceneRendering()->AddActor(this, _sceneRenderingKey);
GetSceneRendering()->AddPhysicsDebug<Cloth, &Cloth::DrawPhysicsDebug>(this);
#endif
#if WITH_CLOTH
@@ -461,6 +466,7 @@ void Cloth::OnDisable()
#endif
#if USE_EDITOR
GetSceneRendering()->RemovePhysicsDebug<Cloth, &Cloth::DrawPhysicsDebug>(this);
GetSceneRendering()->RemoveActor(this, _sceneRenderingKey);
#endif
}
@@ -580,6 +586,8 @@ bool Cloth::CreateCloth()
deformation->AddDeformer(mesh.LODIndex, mesh.MeshIndex, MeshBufferType::Vertex1, deformer);
_meshDeformation = deformation;
}
_lastMinDstSqr = MAX_Real;
#endif
return false;
@@ -588,6 +596,7 @@ bool Cloth::CreateCloth()
void Cloth::DestroyCloth()
{
#if WITH_CLOTH
_lastMinDstSqr = MAX_Real;
if (_meshDeformation)
{
Function<void(const MeshBase*, MeshDeformationData&)> deformer;
@@ -722,20 +731,38 @@ void Cloth::CalculateInvMasses(Array<float>& invMasses)
#endif
}
void Cloth::OnPreUpdate()
bool Cloth::OnPreUpdate()
{
if (!IsActiveInHierarchy())
return true;
if (!_simulationSettings.UpdateWhenOffscreen && _simulationSettings.CullDistance > 0)
{
// Cull based on distance
bool cull = false;
if (_lastMinDstSqr >= Math::Square(_simulationSettings.CullDistance))
cull = true; // Cull
else if (_lastMinDstSqr >= Math::Square(_simulationSettings.CullDistance * 0.8f))
cull = _frameCounter % 4 == 0; // Update once every 4 frames
else if (_lastMinDstSqr >= Math::Square(_simulationSettings.CullDistance * 0.5f))
cull = _frameCounter % 2 == 0; // Update once every 2 frames
_lastMinDstSqr = MAX_Real;
_frameCounter++;
if (cull)
return true;
}
// Get current skinned mesh pose for the simulation of the non-kinematic vertices
if (auto* animatedModel = Cast<AnimatedModel>(GetParent()))
{
if (animatedModel->GraphInstance.NodesPose.IsEmpty() || _paint.IsEmpty())
return;
return false;
const ModelInstanceActor::MeshReference mesh = GetMesh();
if (mesh.Actor == nullptr)
return;
return false;
BytesContainer verticesData;
int32 verticesCount;
if (mesh.Actor->GetMeshData(mesh, MeshBufferType::Vertex0, verticesData, verticesCount))
return;
return false;
PROFILE_CPU_NAMED("Skinned Pose");
auto vbStride = (uint32)verticesData.Length() / verticesCount;
ASSERT(vbStride == sizeof(VB0SkinnedElementType));
@@ -749,6 +776,7 @@ void Cloth::OnPreUpdate()
Array<Matrix> pose;
animatedModel->GetCurrentPose(pose);
const SkeletonData& skeleton = animatedModel->SkinnedModel->Skeleton;
const SkeletonBone* bones = skeleton.Bones.Get();
// Animated model uses skinning thus requires to set vertex position inverse to skeleton bones
const float* paint = _paint.Get();
@@ -763,24 +791,24 @@ void Cloth::OnPreUpdate()
const Float4 blendWeights = vb0.BlendWeights.ToFloat4();
// TODO: optimize this or use _skinningData from AnimatedModel to access current mesh bones data directly
Matrix matrix;
const SkeletonBone& bone0 = skeleton.Bones[vb0.BlendIndices.R];
const SkeletonBone& bone0 = bones[vb0.BlendIndices.R];
Matrix::Multiply(bone0.OffsetMatrix, pose[bone0.NodeIndex], matrix);
Matrix boneMatrix = matrix * blendWeights.X;
if (blendWeights.Y > 0.0f)
{
const SkeletonBone& bone1 = skeleton.Bones[vb0.BlendIndices.G];
const SkeletonBone& bone1 = bones[vb0.BlendIndices.G];
Matrix::Multiply(bone1.OffsetMatrix, pose[bone1.NodeIndex], matrix);
boneMatrix += matrix * blendWeights.Y;
}
if (blendWeights.Z > 0.0f)
{
const SkeletonBone& bone2 = skeleton.Bones[vb0.BlendIndices.B];
const SkeletonBone& bone2 = bones[vb0.BlendIndices.B];
Matrix::Multiply(bone2.OffsetMatrix, pose[bone2.NodeIndex], matrix);
boneMatrix += matrix * blendWeights.Z;
}
if (blendWeights.W > 0.0f)
{
const SkeletonBone& bone3 = skeleton.Bones[vb0.BlendIndices.A];
const SkeletonBone& bone3 = bones[vb0.BlendIndices.A];
Matrix::Multiply(bone3.OffsetMatrix, pose[bone3.NodeIndex], matrix);
boneMatrix += matrix * blendWeights.W;
}
@@ -806,6 +834,8 @@ void Cloth::OnPreUpdate()
PhysicsBackend::UnlockClothParticles(_cloth);
}
return false;
}
void Cloth::OnPostUpdate()
@@ -823,11 +853,28 @@ void Cloth::OnPostUpdate()
// Update bounds (for mesh culling)
auto* actor = (ModelInstanceActor*)GetParent();
actor->UpdateBounds();
if (_sceneRenderingKey != -1)
GetSceneRendering()->UpdateActor(this, _sceneRenderingKey);
}
}
void Cloth::Draw(RenderContext& renderContext)
{
// Update min draw distance for the next simulation tick
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.WorldPosition));
}
void Cloth::Draw(RenderContextBatch& renderContextBatch)
{
// Update min draw distance for the next simulation tick
const RenderContext& renderContext = renderContextBatch.GetMainContext();
_lastMinDstSqr = Math::Min(_lastMinDstSqr, Vector3::DistanceSquared(_transform.Translation, renderContext.View.WorldPosition));
}
void Cloth::RunClothDeformer(const MeshBase* mesh, MeshDeformationData& deformation)
{
if (!IsActiveInHierarchy())
return;
if (!_simulationSettings.ComputeNormals && deformation.Type != MeshBufferType::Vertex0)
return;
#if WITH_CLOTH

23
Source/Engine/Physics/Actors/Cloth.h
View File

@@ -13,6 +13,7 @@
/// </summary>
API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Cloth\"), ActorToolbox(\"Physics\")") class FLAXENGINE_API Cloth : public Actor
{
friend class PhysicsBackend;
DECLARE_SCENE_OBJECT(Cloth);
/// <summary>
@@ -129,12 +130,22 @@ API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Cloth\"), ActorToolbox(\"Ph
/// <summary>
/// Target cloth solver iterations per second. The executed number of iterations per second may vary dependent on many performance factors. However, at least one iteration per frame is solved regardless of the value set.
/// </summary>
API_FIELD() float SolverFrequency = 300.0f;
API_FIELD() float SolverFrequency = 200.0f;
/// <summary>
/// The maximum distance from the camera at which to run cloth simulation. Used to improve performance and skip updating too far clothes. The physics system might reduce the update rate for clothes far enough (eg. half this distance). 0 to disable any culling.
/// </summary>
API_FIELD() float CullDistance = 5000.0f;
/// <summary>
/// If true, the cloth will be updated even when an actor cannot be seen by any camera. Otherwise, the cloth simulation will stop running when the actor is off-screen.
/// </summary>
API_FIELD() bool UpdateWhenOffscreen = false;
/// <summary>
/// The maximum distance cloth particles can move from the original location (within local-space of the actor). Scaled by painted per-particle value (0-1) to restrict movement of certain particles.
/// </summary>
API_FIELD() float MaxDistance = 1000.0f;
API_FIELD() float MaxParticleDistance = 1000.0f;
/// <summary>
/// Enables automatic normal vectors computing for the cloth mesh, otherwise original mesh normals will be used.
@@ -207,6 +218,9 @@ API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Cloth\"), ActorToolbox(\"Ph
private:
void* _cloth = nullptr;
Real _lastMinDstSqr = MAX_Real;
uint32 _frameCounter = 0;
int32 _sceneRenderingKey = -1;
ForceSettings _forceSettings;
CollisionSettings _collisionSettings;
SimulationSettings _simulationSettings;
@@ -220,7 +234,6 @@ public:
/// <summary>
/// Gets the mesh to use for the cloth simulation (single mesh from specific LOD).
/// </summary>
/// <remarks></remarks>
API_PROPERTY(Attributes="EditorOrder(0), EditorDisplay(\"Cloth\")")
ModelInstanceActor::MeshReference GetMesh() const;
@@ -316,11 +329,13 @@ public:
/// </summary>
API_FUNCTION() void SetPaint(Span<const float> value);
void OnPreUpdate();
bool OnPreUpdate();
void OnPostUpdate();
public:
// [Actor]
void Draw(RenderContext& renderContext) override;
void Draw(RenderContextBatch& renderContextBatch) override;
bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
void Serialize(SerializeStream& stream, const void* otherObj) override;
void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;

78
Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp
View File

@@ -41,6 +41,7 @@
#if WITH_CLOTH
#include "Engine/Physics/Actors/Cloth.h"
#include "Engine/Threading/JobSystem.h"
#include "Engine/Threading/Threading.h"
#include <ThirdParty/NvCloth/Callbacks.h>
#include <ThirdParty/NvCloth/Factory.h>
#include <ThirdParty/NvCloth/Cloth.h>
@@ -94,15 +95,12 @@ struct ScenePhysX
#endif
#if WITH_CLOTH
nv::cloth::Solver* ClothSolver = nullptr;
Array<nv::cloth::Cloth*> ClothsList;
#endif
#if WITH_CLOTH
void PreSimulateCloth(int32 i);
void SimulateCloth(int32 i)
{
PROFILE_CPU();
ClothSolver->simulateChunk(i);
}
void SimulateCloth(int32 i);
#endif
};
@@ -171,12 +169,8 @@ struct FabricSettings
Desc.InvMassesStride == r.InvMassesStride)
{
if (Desc.InvMassesData && r.InvMassesData)
{
bool matches = Platform::MemoryCompare(InvMasses.Get(), r.InvMassesData, r.VerticesCount * r.InvMassesStride) == 0;
return matches;
}
bool matches = !Desc.InvMassesData && !r.InvMassesData;
return matches;
return Platform::MemoryCompare(InvMasses.Get(), r.InvMassesData, r.VerticesCount * r.InvMassesStride) == 0;
return !Desc.InvMassesData && !r.InvMassesData;
}
return false;
}
@@ -184,9 +178,10 @@ struct FabricSettings
struct ClothSettings
{
bool Culled = false;
bool SceneCollisions = false;
byte CollisionsUpdateFramesLeft = 0;
bool CollisionsUpdateFramesRandomize = true;
byte CollisionsUpdateFramesLeft = 0;
float GravityScale = 1.0f;
float CollisionThickness = 0.0f;
Cloth* Actor;
@@ -576,6 +571,7 @@ namespace
#endif
#if WITH_CLOTH
CriticalSection ClothLocker;
nv::cloth::Factory* ClothFactory = nullptr;
Dictionary<nv::cloth::Fabric*, FabricSettings> Fabrics;
Dictionary<nv::cloth::Cloth*, ClothSettings> Cloths;
@@ -708,10 +704,28 @@ void InitVehicleSDK()
void ScenePhysX::PreSimulateCloth(int32 i)
{
PROFILE_CPU();
auto clothPhysX = (nv::cloth::Cloth*)ClothSolver->getClothList()[i];
auto clothPhysX = ClothsList[i];
auto& clothSettings = Cloths[clothPhysX];
clothSettings.Actor->OnPreUpdate();
if (clothSettings.Actor->OnPreUpdate())
{
// Cull simulation based on distance
if (!clothSettings.Culled)
{
clothSettings.Culled = true;
ClothLocker.Lock();
ClothSolver->removeCloth(clothPhysX);
ClothLocker.Unlock();
}
return;
}
if (clothSettings.Culled)
{
clothSettings.Culled = false;
ClothLocker.Lock();
ClothSolver->addCloth(clothPhysX);
ClothLocker.Unlock();
}
// Setup automatic scene collisions with colliders around the cloth
if (clothSettings.SceneCollisions && clothSettings.CollisionsUpdateFramesLeft == 0)
@@ -831,7 +845,7 @@ void ScenePhysX::PreSimulateCloth(int32 i)
break;
}
// Cloth vs Triangle collisions are too slow for real-time use
#if 0
#if 0
case PxGeometryType::eTRIANGLEMESH:
{
const PxTriangleMeshGeometry& geomTriangleMesh = (const PxTriangleMeshGeometry&)geo;
@@ -880,6 +894,12 @@ void ScenePhysX::PreSimulateCloth(int32 i)
clothSettings.CollisionsUpdateFramesLeft--;
}
void ScenePhysX::SimulateCloth(int32 i)
{
PROFILE_CPU();
ClothSolver->simulateChunk(i);
}
#endif
void* PhysicalMaterial::GetPhysicsMaterial()
@@ -1632,17 +1652,15 @@ void PhysicsBackend::EndSimulateScene(void* scene)
#if WITH_CLOTH
nv::cloth::Solver* clothSolver = scenePhysX->ClothSolver;
if (clothSolver && clothSolver->getNumCloths() != 0)
if (clothSolver && scenePhysX->ClothsList.Count() != 0)
{
PROFILE_CPU_NAMED("Physics.Cloth");
const int32 clothsCount = scenePhysX->ClothSolver->getNumCloths();
nv::cloth::Cloth* const* cloths = scenePhysX->ClothSolver->getClothList();
{
PROFILE_CPU_NAMED("Pre");
Function<void(int32)> job;
job.Bind<ScenePhysX, &ScenePhysX::PreSimulateCloth>(scenePhysX);
JobSystem::Execute(job, clothsCount);
JobSystem::Execute(job, scenePhysX->ClothsList.Count());
}
{
@@ -1658,10 +1676,12 @@ void PhysicsBackend::EndSimulateScene(void* scene)
{
PROFILE_CPU_NAMED("Post");
for (int32 i = 0; i < clothsCount; i++)
ScopeLock lock(ClothLocker);
for (auto clothPhysX : scenePhysX->ClothsList)
{
auto clothPhysX = (nv::cloth::Cloth*)cloths[i];
const auto& clothSettings = Cloths[clothPhysX];
if (clothSettings.Culled)
continue;
clothSettings.UpdateBounds(clothPhysX);
clothSettings.Actor->OnPostUpdate();
}
@@ -3410,6 +3430,7 @@ void* PhysicsBackend::CreateCloth(const PhysicsClothDesc& desc)
#endif
// Lazy-init NvCloth
ScopeLock lock(ClothLocker);
if (ClothFactory == nullptr)
{
nv::cloth::InitializeNvCloth(&AllocatorCallback, &ErrorCallback, &AssertCallback, &ProfilerCallback);
@@ -3507,6 +3528,7 @@ void* PhysicsBackend::CreateCloth(const PhysicsClothDesc& desc)
void PhysicsBackend::DestroyCloth(void* cloth)
{
ScopeLock lock(ClothLocker);
auto clothPhysX = (nv::cloth::Cloth*)cloth;
if (--Fabrics[&clothPhysX->getFabric()].Refs == 0)
Fabrics.Remove(&clothPhysX->getFabric());
@@ -3559,7 +3581,7 @@ void PhysicsBackend::SetClothSimulationSettings(void* cloth, const void* setting
auto clothPhysX = (nv::cloth::Cloth*)cloth;
const auto& settings = *(const Cloth::SimulationSettings*)settingsPtr;
clothPhysX->setSolverFrequency(settings.SolverFrequency);
clothPhysX->setMotionConstraintScaleBias(settings.MaxDistance, 0.0f);
clothPhysX->setMotionConstraintScaleBias(settings.MaxParticleDistance, 0.0f);
clothPhysX->setWindVelocity(C2P(settings.WindVelocity));
}
@@ -3705,6 +3727,7 @@ void PhysicsBackend::SetClothPaint(void* cloth, Span<const float> value)
void PhysicsBackend::AddCloth(void* scene, void* cloth)
{
ScopeLock lock(ClothLocker);
auto scenePhysX = (ScenePhysX*)scene;
auto clothPhysX = (nv::cloth::Cloth*)cloth;
if (scenePhysX->ClothSolver == nullptr)
@@ -3713,13 +3736,20 @@ void PhysicsBackend::AddCloth(void* scene, void* cloth)
ASSERT(scenePhysX->ClothSolver);
}
scenePhysX->ClothSolver->addCloth(clothPhysX);
scenePhysX->ClothsList.Add(clothPhysX);
}
void PhysicsBackend::RemoveCloth(void* scene, void* cloth)
{
ScopeLock lock(ClothLocker);
auto scenePhysX = (ScenePhysX*)scene;
auto clothPhysX = (nv::cloth::Cloth*)cloth;
scenePhysX->ClothSolver->removeCloth(clothPhysX);
auto& clothSettings = Cloths[clothPhysX];
if (clothSettings.Culled)
clothSettings.Culled = false;
else
scenePhysX->ClothSolver->removeCloth(clothPhysX);
scenePhysX->ClothsList.Remove(clothPhysX);
}
#endif