file
namespace    UE::Chaos::ClothAsset
function     void FClothSimulationContext::Fill

namespace UE::Chaos::ClothAsset
{
	void FClothSimulationContext::Fill(const UChaosClothComponent& ClothComponent, float InDeltaTime, float MaxDeltaTime, bool bIsInitialization, FClothingSimulationCacheData* InCacheData)
	{
		// Set the time
		DeltaTime = FMath::Min(InDeltaTime, MaxDeltaTime);

		// Set the current LOD index
		LodIndex = ClothComponent.GetPredictedLODLevel();

		// Set the teleport mode
		static const IConsoleVariable* const CVarMaxDeltaTimeTeleportMultiplier = IConsoleManager::Get().FindConsoleVariable(TEXT("p.Cloth.MaxDeltaTimeTeleportMultiplier"));

file
namespace    UE::Chaos::ClothAsset
function     void FClothSimulationContext::Fill

		const float MaxDeltaTimeTeleportMultiplier = CVarMaxDeltaTimeTeleportMultiplier ? CVarMaxDeltaTimeTeleportMultiplier->GetFloat() : MaxDeltaTimeTeleportMultiplierDefault;

		bTeleport = (DeltaTime > MaxDeltaTime * MaxDeltaTimeTeleportMultiplier) ? true : ClothComponent.NeedsTeleport();
		bReset = ClothComponent.NeedsReset();

		VelocityScale = (!bTeleport && !bReset && InDeltaTime > 0.f) ?
			FMath::Min(InDeltaTime, MaxDeltaTime) / InDeltaTime :
			bReset ? 1.f : 0.f;  // Set to 0 when teleporting and 1 when resetting to match the internal solver's behavior

		// Copy component transform
		ComponentTransform = ClothComponent.GetComponentTransform();

		// Update bone transforms

file
namespace    UE::Chaos::ClothAsset

		/** Fill the context from data collected from the specified component. */
		void Fill(const UChaosClothComponent& ClothComponent, float InDeltaTime, float MaxDeltaTime, bool bIsInitialization = false, FClothingSimulationCacheData* CacheData = nullptr);
	};
}

file
namespace    UE::Chaos::ClothAsset
function     FClothSimulationProxy::FClothSimulationProxy

		, Solver(nullptr)
		, Visualization(nullptr)
		, MaxDeltaTime(UPhysicsSettings::Get()->MaxPhysicsDeltaTime)
	{
		using namespace ::Chaos;

		check(IsInGameThread());

		// Create solver config simulation thread object first. Need to know which solver type we're creating.

file
namespace    UE::Chaos::ClothAsset
function     FClothSimulationProxy::FClothSimulationProxy

		constexpr bool bIsInitialization = true;
		constexpr Softs::FSolverReal NoAdvanceDt = 0.f;
		ClothSimulationContext->Fill(ClothComponent, NoAdvanceDt, MaxDeltaTime, bIsInitialization);

		// Setup startup transforms
		constexpr bool bNeedsReset = true;
		Solver->SetLocalSpaceLocation((FVec3)ClothSimulationContext->ComponentTransform.GetLocation(), bNeedsReset);
		Solver->SetLocalSpaceRotation((FQuat)ClothSimulationContext->ComponentTransform.GetRotation());

file
namespace    UE::Chaos::ClothAsset
function     FClothSimulationProxy::FClothSimulationProxy

		// Set start pose (update the context, then the solver without advancing the simulation)
		ClothSimulationContext->Fill(ClothComponent, NoAdvanceDt, MaxDeltaTime);
		Solver->Update((Softs::FSolverReal)ClothSimulationContext->DeltaTime);
	}

	FClothSimulationProxy::~FClothSimulationProxy()
	{
		CompleteParallelSimulation_GameThread();

file
namespace    UE::Chaos::ClothAsset
function     void FClothSimulationProxy::FillSimulationContext

	void FClothSimulationProxy::FillSimulationContext(float DeltaTime, bool bIsInitialization)
	{
		ClothSimulationContext->Fill(ClothComponent, DeltaTime, MaxDeltaTime, bIsInitialization, CacheData.Get());
		CacheData.Reset();
	}

	bool FClothSimulationProxy::ShouldEnableSolver(bool bSolverCurrentlyEnabled) const
	{
		switch (SolverMode)

file
namespace    UE::Chaos::ClothAsset
class        class FClothSimulationProxy

		// Cached value of the MaxPhysicsDeltaTime setting for the life of this proxy
		const float MaxDeltaTime;
	};

#if !defined(CHAOS_TRANSFORM_CLOTH_SIMUL_DATA_ISPC_ENABLED_DEFAULT)
#define CHAOS_TRANSFORM_CLOTH_SIMUL_DATA_ISPC_ENABLED_DEFAULT 1
#endif

file
namespace    UE::ConcertSyncTests::Replication::Frequency

			constexpr double AcceptableTimeRange = UpdateIntervalSeconds * 0.01;
			constexpr double MinDeltaTime = UpdateIntervalSeconds - AcceptableTimeRange;
			constexpr double MaxDeltaTime = UpdateIntervalSeconds + AcceptableTimeRange;
			if (bReceivedServer)
			{
				const bool bMin = MinDeltaTime <= DeltaSecSinceLast_Server || bIsFirstServerReceive;
				const bool bMax = DeltaSecSinceLast_Server <= MaxDeltaTime || bIsFirstServerReceive;
				AddErrorIfFalse(bMin, FString::Printf(TEXT("Server: MinDeltaTime (%f) <= DeltaSecSinceLast_Server (%f)"), MinDeltaTime, DeltaSecSinceLast_Server));
				AddErrorIfFalse(bMax, FString::Printf(TEXT("Server: DeltaSecSinceLast_Server (%f) <= MaxDeltaTime (%f)"), DeltaSecSinceLast_Server, MaxDeltaTime));
				bIsFirstServerReceive = false;
			}
			if (bReceivedClient)
			{
				const bool bMin = MinDeltaTime <= DeltaSecSinceLast_Client || bIsFirstClientReceive;
				const bool bMax = DeltaSecSinceLast_Client <= MaxDeltaTime || bIsFirstClientReceive;
				AddErrorIfFalse(bMin, FString::Printf(TEXT("Client: MinDeltaTime (%f) <= DeltaSecSinceLast_Client (%f)"), MinDeltaTime, DeltaSecSinceLast_Client));
				AddErrorIfFalse(bMax, FString::Printf(TEXT("Client: DeltaSecSinceLast_Client (%f) <= MaxDeltaTime (%f)"), DeltaSecSinceLast_Client, MaxDeltaTime));
				bIsFirstClientReceive = false;
			}
		}

		// 2.2 Verify that the expected number of events was received in the past 1 second
		// We may be off by one event due to double rounding errors
		constexpr uint8 AcceptableDropAmount = 1;
		constexpr uint8 MinExpected = GetUpdateRate() - AcceptableDropAmount;
		constexpr uint8 MaxExpected = GetUpdateRate();
		AddErrorIfFalse(MinExpected <= NumServerReceived, FString::Printf(TEXT("Server: MinExpected (%d)<= NumServerReceived (%d)"), MinExpected, NumServerReceived));
		AddErrorIfFalse(NumServerReceived <= MaxExpected, FString::Printf(TEXT("Server: NumServerReceived (%d) <= MaxExpected (%d)"), NumServerReceived, MaxExpected));
		AddErrorIfFalse(MinExpected <= NumClientReceived, FString::Printf(TEXT("Server: MinExpected (%d)<= NumClientReceived (%d)"), MinExpected, NumClientReceived));
		AddErrorIfFalse(NumClientReceived <= MaxExpected, FString::Printf(TEXT("Server: NumClientReceived (%d) <= MaxExpected (%d)"), NumClientReceived, MaxExpected));

		// 2.1 (time between updates) and 2.2 (number of updates) correctly test that we replicate at the expected frequency.
		return true;
	}*/
}

#endif

file
function     bool UVPTimecodeCustomTimeStep::UpdateTimeStep

	// Loop until we have a new timecode value
	MaxDeltaTime = FMath::Max(0.f, MaxDeltaTime);

	double ActualWaitTime = 0.0;
	bool bSucceed = false;
	FTimecode NewTimecode;
	{
		FSimpleScopeSecondsCounter ActualWaitTimeCounter(ActualWaitTime);

		double BeforeSeconds = FPlatformTime::Seconds();
		while(FPlatformTime::Seconds() - BeforeSeconds < MaxDeltaTime)
		{
			UTimecodeProvider* TimecodeProvider = InEngine->GetTimecodeProvider();

			if (TimecodeProvider == nullptr)
			{
				UE_LOG(LogVPUtilities, Error, TEXT("There is no Timecode Provider for '%s'."), *GetName());

file
function     bool UVPTimecodeCustomTimeStep::UpdateTimeStep

	if (!bSucceed)
	{
		UE_LOG(LogVPUtilities, Error, TEXT("It took more than %f to update '%s'."), MaxDeltaTime, *GetName());
		State = ECustomTimeStepSynchronizationState::Error;
	}

	return false; // do not execute the engine time step
}

file
class        class UVPTimecodeCustomTimeStep : public UFixedFrameRateCustomTimeStep

	/** If the timecode doesn't change after that amount of time, stop the CustomTimeStep. */
	UPROPERTY(EditAnywhere, Category = "CustomTimeStep")
	float MaxDeltaTime = 0.5f;

private:
	bool InitializeFirstStep(UEngine* InEngine);

	void OnTimecodeProviderChanged();

file
class        class UNiagaraSystem : public UFXSystemAsset, public INiagaraParameterDefinitionsSubscriber
function     TOptional<float> GetMaxDeltaTime

	NIAGARA_API const UNiagaraScript* GetSystemUpdateScript() const;

	TOptional<float> GetMaxDeltaTime() const { return MaxDeltaTime; }
	const FNiagaraDataSetAccessor<ENiagaraExecutionState>& GetSystemExecutionStateAccessor() const { return SystemExecutionStateAccessor; }
	TConstArrayView<FNiagaraDataSetAccessor<ENiagaraExecutionState>> GetEmitterExecutionStateAccessors() const { return MakeArrayView(EmitterExecutionStateAccessors); }
	TConstArrayView<FNiagaraDataSetAccessor<FNiagaraSpawnInfo>> GetEmitterSpawnInfoAccessors(int32 EmitterIndex) const { return MakeArrayView(EmitterSpawnInfoAccessors[EmitterIndex]);  }
	
	/** Performs the passed action for all scripts in this system.
	    Include NiagaraSystemImpl.h to be able to call this function */

file
class        class UNiagaraSystem : public UFXSystemAsset, public INiagaraParameterDefinitionsSubscriber

	uint32 bLwcEnabledSettingCached : 1;

	TOptional<float> MaxDeltaTime;
	FNiagaraDataSetAccessor<ENiagaraExecutionState> SystemExecutionStateAccessor;
	TArray<FNiagaraDataSetAccessor<ENiagaraExecutionState>> EmitterExecutionStateAccessors;
	TArray<TArray<FNiagaraDataSetAccessor<FNiagaraSpawnInfo>>> EmitterSpawnInfoAccessors;

	FGraphEventRef ScriptOptimizationCompletionEvent;
	FGraphEventRef PSOPrecacheCompletionEvent;

file
function     void UNiagaraSystem::CacheFromCompiledData

	EmitterSpawnInfoAccessors.SetNum(GetNumEmitters());

	// reset the MaxDeltaTime so we get the most up to date values from the emitters
	MaxDeltaTime.Reset();

	FGraphEventArray PSOPrecacheEvents;

	TSet<FName> DataInterfaceGpuUsage;
	FNameBuilder ExecutionStateNameBuilder;
	for (int32 i=0; i < EmitterHandles.Num(); ++i)

file
function     void UNiagaraSystem::CacheFromCompiledData

					if (NiagaraSettings->bLimitDeltaTime)
					{
						MaxDeltaTime = MaxDeltaTime.IsSet() ? FMath::Min(MaxDeltaTime.GetValue(), NiagaraSettings->MaxDeltaTimePerTick) : NiagaraSettings->MaxDeltaTimePerTick;
					}
				}
				EmitterHandle.GetInstance().Emitter->ConditionalPostLoad();
				EmitterData->CacheFromCompiledData(DataSetCompiledData, *EmitterHandle.GetInstance().Emitter);

				PSOPrecacheEvents.Append(EmitterData->PrecacheComputePSOs(*EmitterHandle.GetInstance().Emitter));

file
function     bool FNiagaraSystemSimulation::Init

	bSystemStateFastPathEnabled = System->SystemStateFastPathEnabled();

	MaxDeltaTime = System->GetMaxDeltaTime();

	if (bCanExecute)
	{
		{
			//SCOPE_CYCLE_COUNTER(STAT_NiagaraSystemSim_Init_DataSets);

file
function     void FNiagaraSystemSimulation::Tick_GameThread_Internal

	check(GetSystemInstances(ENiagaraSystemInstanceState::Paused).Num() == PausedDataSet.GetCurrentDataChecked().GetNumInstances());

	if (MaxDeltaTime.IsSet() && !System->HasFixedTickDelta())
	{
		DeltaSeconds = FMath::Clamp(DeltaSeconds, 0.0f, MaxDeltaTime.GetValue());

		TickInfo.SystemTick = DeltaSeconds;
		TickInfo.TimeStepFraction = DeltaSeconds / TickInfo.EngineTick;
	}

	UNiagaraScript* SystemSpawnScript = System->GetSystemSpawnScript();

file
function     void FNiagaraSystemSimulation::Spawn_GameThread

	bInSpawnPhase = true;

	if (MaxDeltaTime.IsSet())
	{
		DeltaSeconds = FMath::Clamp(DeltaSeconds, 0.0f, MaxDeltaTime.GetValue());
	}
	if (System->HasFixedTickDelta())
	{
		DeltaSeconds = System->GetFixedTickDeltaTime();
	}

file
class        class FNiagaraSystemSimulation : public TSharedFromThis<FNiagaraSystemSimulation, ESPMode::ThreadSafe>

	void InitParameterDataSetBindings(FNiagaraSystemInstance* SystemInst);

	TOptional<float> MaxDeltaTime;

	/** Event to track the system simulation async tick is complete. */
	FGraphEventRef ConcurrentTickGraphEvent;
	/** Event to track all work is complete, i.e. System Concurrent, Instance Concurrent, Finalize */
	FGraphEventRef AllWorkCompleteGraphEvent;

file
function     void FRandomGraphTrack::GenerateSeries

	constexpr double MinDeltaTime = 0.0000001; // 100ns
	constexpr double MaxDeltaTime = 0.01; // 100ms

	float MinValue = (Seed == 0) ? 0.0f : (Seed == 1) ? -0.25f : -0.5f;
	float MaxValue = (Seed == 0) ? 0.5f : (Seed == 1) ? +0.25f :  0.0f;

	struct FGraphEvent
	{

file
function     void FRandomGraphTrack::GenerateSeries

		FGraphEvent Ev;
		Ev.Time = NextT;
		const double TimeAdvance = RandomStream.GetFraction() * (MaxDeltaTime - MinDeltaTime);
		NextT += MinDeltaTime + TimeAdvance;
		Ev.Duration = MinDeltaTime + RandomStream.GetFraction() * TimeAdvance;
		Ev.Value = MinValue + RandomStream.GetFraction() * (MaxValue - MinValue);
		Events.Add(Ev);
	}

file
function     void FAnimNode_AnimDynamics::EvaluateSkeletalControl_AnyThread

			{
				// Do variable frame-time update
				const float MaxDeltaTime = MaxPhysicsDeltaTime;

				NextTimeStep = FMath::Min(NextTimeStep, MaxDeltaTime);

				UpdateLimits(Output);
				FAnimPhys::PhysicsUpdate(NextTimeStep, SimBodies, LinearLimits, AngularLimits, Springs, SimSpaceGravityDirection, OrientedExternalForce, ComponentLinearAcc, NumSolverIterationsPreUpdate, NumSolverIterationsPostUpdate);
			}

#if ENABLE_ANIM_DRAW_DEBUG

file
function     FAnimNode_Trail::FAnimNode_Trail

	, TrailRelaxation_DEPRECATED(10.f)
#endif// #if WITH_EDITORONLY_DATA
	, MaxDeltaTime(0.f)
	, RelaxationSpeedScale(1.f)
	, StretchLimit(0)
	, FakeVelocity(FVector::ZeroVector)
#if WITH_EDITORONLY_DATA
	, TrailBoneRotationBlendAlpha_DEPRECATED(1.f)
#endif // WITH_EDITORONLY_DATA

file
function     void FAnimNode_Trail::EvaluateSkeletalControl_AnyThread

	check(OutBoneTransforms.Num() == 0);
	const float TimeStep = (MaxDeltaTime > 0.f)? FMath::Clamp(ThisTimstep, 0.f, MaxDeltaTime) : ThisTimstep;
	ThisTimstep = 0.f;

	if( ChainBoneIndices.Num() <= 0 )
	{
		return;
	}

#endif // WITH_EDITORONLY_DATA

	/** To avoid hitches causing stretch of trail, you can use MaxDeltaTime to clamp the long delta time. If you want 30 fps to set it to 0.03333f ( = 1/30 ).  */
	UPROPERTY(EditAnywhere, Category = Limit)
	float MaxDeltaTime;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Trail, meta = (PinHiddenByDefault))
	float RelaxationSpeedScale;

	/** How quickly we 'relax' the bones to their animated positions. Time 0 will map to top root joint, time 1 will map to the bottom joint. */
	UPROPERTY(EditAnywhere, Category=Trail, meta=(CustomizeProperty))

file
class        class UGameEngine : public UEngine

	/** Maximium delta time the engine uses to populate FApp::DeltaTime. If 0, unbound. */
	UPROPERTY(config)
	float MaxDeltaTime;

	/** Maximium time (in seconds) between the flushes of the logs on the server (best effort). If 0, this will happen every tick. */
	UPROPERTY(config)
	float ServerFlushLogInterval;

	UPROPERTY(transient)

file
function     void UEngine::UpdateTimeAndHandleMaxTickRate

		// Enforce a maximum delta time if wanted.
		UGameEngine* GameEngine = Cast<UGameEngine>(this);
		const float MaxDeltaTime = GameEngine ? GameEngine->MaxDeltaTime : 0.f;
		if( MaxDeltaTime > 0.f )
		{
			UWorld* World = NULL;

			int32 NumGamePlayers = 0;
			for (int32 WorldIndex = 0; WorldIndex < WorldList.Num(); ++WorldIndex)
			{

file
function     void UEngine::UpdateTimeAndHandleMaxTickRate

			{
				// Happy clamping!
				FApp::SetDeltaTime(FMath::Min<double>(FApp::GetDeltaTime(), MaxDeltaTime));
			}
		}
	}

	bPreviousUseFixedTimeStep = bUseFixedTimeStep;

file
namespace    Chaos
class        class AdvanceOneTimeStepTask : public FNonAbandonableTask
function     void DoWork

				//   energy will be lost.
				const FReal MinDeltaTime = MSolver->GetMinDeltaTime_External();
				const FReal MaxDeltaTime = MSolver->GetMaxDeltaTime_External();
				int32 StepsRemaining = MSubStepInfo.bSolverSubstepped ? 1 : MSolver->GetMaxSubSteps_External();
				FReal TimeRemaining = MDeltaTime;
				bool bFirstStep = true;
				while (StepsRemaining > 0 && TimeRemaining > MinDeltaTime)
				{
					--StepsRemaining;
					const FReal DeltaTime = MaxDeltaTime > 0.f ? FMath::Min(TimeRemaining, MaxDeltaTime) : TimeRemaining;
					TimeRemaining -= DeltaTime;

					{
						MSolver->FieldForcesUpdateCallback();
					}