ConstraintGroupSolver.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Chaos/Core.h"
#include "Chaos/Evolution/IterationSettings.h"
#include "Chaos/Evolution/SolverBodyContainer.h"
#include "Containers/Array.h"
 
namespace Chaos
{
    class FConstraintContainerSolver;
    class FPBDConstraintContainer;
 
    namespace Private
    {
        class FPBDConstraintGroupSolver
        {
        public:
            UE_NONCOPYABLE(FPBDConstraintGroupSolver);
 
            CHAOS_API FPBDConstraintGroupSolver();
            CHAOS_API virtual ~FPBDConstraintGroupSolver();
 
            FIterationSettings GetIterationSettings() const
            {
                return Iterations;
            }
 
            virtual void SetIterationSettings(const FIterationSettings& InIterations)
            {
                Iterations = InIterations;
            }
 
            inline int32 GetNumSolverBodies() const
            {
                return SolverBodyContainer.Num();
            }
 
            inline int32 GetNumSolverConstraints() const
            {
                return TotalNumConstraints;
            }
 
            CHAOS_API void SetConstraintSolver(const int32 ContainerId, TUniquePtr<FConstraintContainerSolver>&& Solver);
 
            CHAOS_API void SetConstraintSolverPriority(const int32 ContainerId, const int32 Priority);
 
            CHAOS_API void Reset();
 
            CHAOS_API void AddConstraintsAndBodies();
 
            CHAOS_API void GatherBodies(const FReal Dt);
 
            CHAOS_API void GatherBodies(const FReal Dt, const int32 BeginBodyIndex, const int32 EndBodyIndex);
 
            CHAOS_API void GatherConstraints(const FReal Dt);
 
            CHAOS_API void GatherConstraints(const FReal Dt, const int32 BeginConstraintIndex, const int32 EndConstraintIndex);
 
            CHAOS_API void PreApplyPositionConstraints(const FReal Dt);
            CHAOS_API void PreApplyVelocityConstraints(const FReal Dt);
            CHAOS_API void PreApplyProjectionConstraints(const FReal Dt);
 
            CHAOS_API void ApplyPositionConstraints(const FReal Dt);
 
            CHAOS_API void ApplyVelocityConstraints(const FReal Dt);
 
            CHAOS_API void ApplyProjectionConstraints(const FReal Dt);
 
            CHAOS_API void ScatterBodies(const FReal Dt);
 
            CHAOS_API void ScatterBodies(const FReal Dt, const int32 BeginBodyIndex, const int32 EndBodyIndex);
 
            CHAOS_API void ScatterConstraints(const FReal Dt);
 
            CHAOS_API void ScatterConstraints(const FReal Dt, const int32 BeginConstraintIndex, const int32 EndConstraintIndex);
 
        protected:
 
            // Loop over the range of constraints and apply the lambda. The range is treats constraints of all types as a contiguous list
            // and the function loops over constraint types and maps the range into the solver ranges for each type.
            template<typename LambdaType>
            void ApplyToConstraintRange(const int32 BeginConstraintIndex, const int32 EndConstraintIndex, const LambdaType& Lambda);
 
            // Sort the solvers based on Level and other criteria for more stable solving
            CHAOS_API void SortSolverContainers();
 
            // Allow a derived class to perform per-tick reset
            virtual void ResetImpl() {}
 
            // Allow a derived class to add data based on the number of constraint types we need to support
            virtual void SetConstraintSolverImpl(const int32 ContainerId) {}
 
            // Allow a derived class to add constraints solvers
            virtual void AddConstraintsImpl() {}
 
            // Allow a derived class to populate some of the SolverBody data (Level and Color)
            virtual void GatherBodiesImpl(const FReal Dt, const int32 BeginBodyIndex, const int32 EndBodyIndex) {}
 
            // All the bodies used by all the constraints solved by this group
            FSolverBodyContainer SolverBodyContainer;
 
            // A solver for each constraint type in the group
            TArray<TUniquePtr<FConstraintContainerSolver>> ConstraintContainerSolvers;
            int32 TotalNumConstraints;
 
            // Sorted by priority for use in solve methods
            TArray<FConstraintContainerSolver*> PrioritizedConstraintContainerSolvers;
 
            FIterationSettings Iterations;
        };
 
 
        //
        //
        //
        //
        //
 
        class FPBDSceneConstraintGroupSolver : public FPBDConstraintGroupSolver
        {
        public:
            FPBDSceneConstraintGroupSolver(const FIterationSettings& InIterations)
            {
                Iterations = InIterations;
            }
 
        protected:
            // The Scene Group Solver adds all constraints from all containers
            CHAOS_API virtual void AddConstraintsImpl() override final;
        };
 
    } // namespace Private
 
 
    //UE_DEPRECATED(5.2, "FPBDConstraintGroupSolver is for internal use only")
    //using FPBDConstraintGroupSolver = Private::FPBDConstraintGroupSolver;
 
 
    //UE_DEPRECATED(5.2, "FPBDSceneConstraintGroupSolver is for internal use only")
    //using FPBDSceneConstraintGroupSolver = Private::FPBDSceneConstraintGroupSolver;
 
}   // namespace Chaos