Apparatus Version 1.22
ECS data-oriented workflow for Unreal Engine.
Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
IMechanical Class Reference

A common interface for all mechanisms. More...

#include <Mechanical.h>

Inheritance diagram for IMechanical:
Inheritance graph
[legend]

Public Member Functions

AMechanismGetMechanism () const
 Get the mechanism this mechanical is part of. More...
 
FSubjectHandle SpawnSubject (const EFlagmark Flagmark=FM_None)
 Spawn a new subject, returning its handle. More...
 
template<typename ChainT = TChain<TChunkIt<FSubjectHandle>, TBeltIt<FSubjectHandle>>>
TSharedRef< ChainT > Enchain (const FFilter &InFilter) const
 Enchain iterables using the supplied filter. More...
 
TSharedRef< TChain< TChunkIt< FSolidSubjectHandle >, TBeltIt< FSolidSubjectHandle > > > EnchainSolid (const FFilter &InFilter) const
 Solid-enchain iterables using the supplied filter. More...
 
void ReceiveBoot ()
 Process newly created subjects. More...
 
void ReceiveInputTick ()
 Process a pre-steady input tick. More...
 
void ReceiveSteadyTick (float DeltaSeconds)
 Process a fixed-rate steady tick. More...
 
void ReceivePresentationTick (float DeltaSeconds, float FrameRatio, float FutureFactor)
 Process a past-steady presentation tick. More...
 
virtual void Boot ()
 Process newly created subjects. More...
 
virtual void InputTick ()
 Process a pre-steady input tick. More...
 
virtual void SteadyTick (float DeltaTime)
 Process a fixed-rate steady tick. More...
 
virtual void PresentationTick (float DeltaSeconds, float FrameRatio, float FutureFactor)
 Process a past-steady presentation tick. More...
 
 IMechanical ()
 
virtual float GetSteadyDeltaTime () const
 Get the time interval for steady ticking. More...
 
virtual float GetOwnTime () const
 Get own Mechanical's local life time. More...
 
float GetProcessedSteadyTime () const
 Get the time of the last processed steady frame. More...
 
float CalcSteadyFrameRatio () const
 The current ratio within the steady frame. More...
 
void GetSteadyFrame (int64 &OutFrame) const
 Get the current steady frame. More...
 
float GetSteadyTime () const
 Get the total steady time elapsed. More...
 
float CalcSteadyFutureFactor () const
 The current steady future factor. More...
 
Operating
template<typename ChainT = void, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type Operate (FilterT &&Filter, const MechanicT &Mechanic)
 Process the mechanism using a functor mechanic. More...
 
template<typename ChainT = void, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type Operate (FilterT &&Filter, MechanicT &Mechanic)
 Process the mechanism using a functor mechanic. More...
 
template<typename ChainT = void, typename FilterT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type Operate (FilterT &&Filter, FunctionT *const Mechanic)
 Process the chain using a free function mechanic. More...
 
template<typename ChainT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type Operate (const MechanicT &Mechanic)
 Process the mechanism using a functor mechanic. More...
 
template<typename ChainT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type Operate (MechanicT &Mechanic)
 Process the mechanism using a functor mechanic. More...
 
template<typename ChainT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value, EApparatusStatus >::type Operate (FunctionT *const Mechanic)
 Process the chain using a free function mechanic. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type OperateConcurrently (FilterT &&Filter, const MechanicT &Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the mechanism using a functor mechanic in a threaded manner. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type OperateConcurrently (FilterT &&Filter, MechanicT &Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the mechanism using a functor mechanic in a threaded manner. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type OperateConcurrently (FilterT &&Filter, FunctionT *const Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the chain using a free function mechanic in a parallel manner. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type OperateConcurrently (const MechanicT &Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the mechanism using a functor mechanic in a threaded manner. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type OperateConcurrently (MechanicT &Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the mechanism using a functor mechanic in a threaded manner. More...
 
template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value, EApparatusStatus >::type OperateConcurrently (FunctionT *const Mechanic, const int32 ThreadsCountMax, const int32 SlotsPerThreadMin=1, const bool bSync=true)
 Process the chain using a free function mechanic in a parallel manner. More...
 

Protected Member Functions

virtual void DoTick (float NewTime, float DeltaTime, float SteadyDeltaTime)
 Perform a standard ticking routine. More...
 
void DoRegister ()
 
void DoUnregister ()
 
void DoPostLogin (APlayerController *NewPlayer)
 
float DoGetProcessedSteadyTime (float SteadyDeltaTime) const
 
float DoCalcSteadyFrameRatio (const float Time, const float SteadyDeltaTime) const
 
float DoCalcSteadyFutureFactor (const float Time, const float SteadyDeltaTime) const
 
float GetProcessedSteadyTime_Implementation () const
 
float CalcSteadyFrameRatio_Implementation () const
 
void GetSteadyFrame_Implementation (int64 &OutFrame) const
 
float CalcSteadyFutureFactor_Implementation () const
 
float GetSteadyTime_Implementation () const
 

Protected Attributes

int64 SteadyFrame = 0
 The steady frame we are currently part of. More...
 
int64 ProcessedSteadyFrame = -1
 The last, actually processed steady frame. More...
 
float PrevTime = NAN
 The game time of the previous tick. More...
 
uint32 bInsideTick: 1
 Is this mechanism currently updating? More...
 
uint32 bInsideSteadyTick: 1
 Is this mechanism currently in the process of steady ticking? More...
 
uint32 bInsidePresentationTick: 1
 Is this mechanism currently in the process of presentation ticking? More...
 

Friends

class UMachine
 

Detailed Description

A common interface for all mechanisms.

Constructor & Destructor Documentation

◆ IMechanical()

IMechanical::IMechanical ( )
inline

Member Function Documentation

◆ Boot()

virtual void IMechanical::Boot ( )
inlinevirtual

Process newly created subjects.

◆ CalcSteadyFrameRatio()

float IMechanical::CalcSteadyFrameRatio ( ) const
inline

The current ratio within the steady frame.

This is in relation between the previous steady frame and the current next one. Should be used for interframe interpolation.

◆ CalcSteadyFrameRatio_Implementation()

float IMechanical::CalcSteadyFrameRatio_Implementation ( ) const
inlineprotected

◆ CalcSteadyFutureFactor()

float IMechanical::CalcSteadyFutureFactor ( ) const
inline

The current steady future factor.

This is in relation between the previous change time delta to the next steady frame change delta time.

◆ CalcSteadyFutureFactor_Implementation()

float IMechanical::CalcSteadyFutureFactor_Implementation ( ) const
inlineprotected

◆ DoCalcSteadyFrameRatio()

float IMechanical::DoCalcSteadyFrameRatio ( const float  Time,
const float  SteadyDeltaTime 
) const
inlineprotected

◆ DoCalcSteadyFutureFactor()

float IMechanical::DoCalcSteadyFutureFactor ( const float  Time,
const float  SteadyDeltaTime 
) const
inlineprotected

◆ DoGetProcessedSteadyTime()

float IMechanical::DoGetProcessedSteadyTime ( float  SteadyDeltaTime) const
inlineprotected

◆ DoPostLogin()

void IMechanical::DoPostLogin ( APlayerController *  NewPlayer)
protected

◆ DoRegister()

void IMechanical::DoRegister ( )
protected

◆ DoTick()

void IMechanical::DoTick ( float  NewTime,
float  DeltaTime,
float  SteadyDeltaTime 
)
inlineprotectedvirtual

Perform a standard ticking routine.

The function can be used in the descendants to perform a standard ticking routine.

◆ DoUnregister()

void IMechanical::DoUnregister ( )
protected

◆ Enchain()

template<typename ChainT = TChain<TChunkIt<FSubjectHandle>, TBeltIt<FSubjectHandle>>>
TSharedRef< ChainT > IMechanical::Enchain ( const FFilter InFilter) const

Enchain iterables using the supplied filter.

Parameters
InFilterA filter to enchain with.
Returns
A pointer to a chain.

◆ EnchainSolid()

TSharedRef< TChain< TChunkIt< FSolidSubjectHandle >, TBeltIt< FSolidSubjectHandle > > > IMechanical::EnchainSolid ( const FFilter InFilter) const

Solid-enchain iterables using the supplied filter.

Parameters
InFilterA filter to enchain with.
Returns
A pointer to a chain.

◆ GetMechanism()

AMechanism * IMechanical::GetMechanism ( ) const

Get the mechanism this mechanical is part of.

◆ GetOwnTime()

virtual float IMechanical::GetOwnTime ( ) const
inlinevirtual

Get own Mechanical's local life time.

Should be overriden in the descendants.

Reimplemented in AMechanicalActor, UMechanicalActorComponent, AMechanicalGameMode, AMechanicalGameModeBase, and AMechanicalPlayerController.

◆ GetProcessedSteadyTime()

float IMechanical::GetProcessedSteadyTime ( ) const
inline

Get the time of the last processed steady frame.

◆ GetProcessedSteadyTime_Implementation()

float IMechanical::GetProcessedSteadyTime_Implementation ( ) const
inlineprotected

◆ GetSteadyDeltaTime()

virtual float IMechanical::GetSteadyDeltaTime ( ) const
inlinevirtual

Get the time interval for steady ticking.

Should be overriden in the descendants to provide a propertie's value.

Reimplemented in AMechanicalActor, UMechanicalActorComponent, AMechanicalGameMode, AMechanicalGameModeBase, and AMechanicalPlayerController.

◆ GetSteadyFrame()

void IMechanical::GetSteadyFrame ( int64 &  OutFrame) const

Get the current steady frame.

◆ GetSteadyFrame_Implementation()

void IMechanical::GetSteadyFrame_Implementation ( int64 &  OutFrame) const
inlineprotected

◆ GetSteadyTime()

float IMechanical::GetSteadyTime ( ) const
inline

Get the total steady time elapsed.

◆ GetSteadyTime_Implementation()

float IMechanical::GetSteadyTime_Implementation ( ) const
inlineprotected

◆ InputTick()

virtual void IMechanical::InputTick ( )
inlinevirtual

Process a pre-steady input tick.

◆ Operate() [1/6]

template<typename ChainT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type IMechanical::Operate ( const MechanicT &  Mechanic)

Process the mechanism using a functor mechanic.

Supports lambdas. Constant mechanic auto-filter version.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor argument types by default.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
MechanicThe functor mechanic to operate with. Can be a lambda expression.
Returns
The status of the operation.

◆ Operate() [2/6]

template<typename ChainT = void, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::Operate ( FilterT &&  Filter,
const MechanicT &  Mechanic 
)

Process the mechanism using a functor mechanic.

Supports lambdas. Constant mechanic version.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor argument types by default.
FilterTThe type of filter that takes place.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
FilterThe filter to query with.
MechanicThe functor mechanic to operate with. Can be a lambda expression.
Returns
The status of the operation.

◆ Operate() [3/6]

template<typename ChainT = void, typename FilterT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::Operate ( FilterT &&  Filter,
FunctionT *const  Mechanic 
)

Process the chain using a free function mechanic.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on function's argument types by default.
FilterTThe type of filter that takes place.
FunctionTThe type of the mechanic function to operate on the slots.
Parameters
FilterThe filter to query with.
MechanicThe mechanical function to operate with.

◆ Operate() [4/6]

template<typename ChainT = void, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::Operate ( FilterT &&  Filter,
MechanicT &  Mechanic 
)

Process the mechanism using a functor mechanic.

Supports lambdas. Mutable mechanic version.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor argument types by default.
FilterTThe type of filter that takes place.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
FilterThe filter to query with.
MechanicThe functor mechanic to operate with. Can be a lambda expression.
Returns
The status of the operation.

◆ Operate() [5/6]

template<typename ChainT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value, EApparatusStatus >::type IMechanical::Operate ( FunctionT *const  Mechanic)

Process the chain using a free function mechanic.

Auto-filter version.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on function's argument types by default.
FunctionTThe type of the mechanic function to operate on the slots.
Parameters
MechanicThe mechanical function to operate with.

◆ Operate() [6/6]

template<typename ChainT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type IMechanical::Operate ( MechanicT &  Mechanic)

Process the mechanism using a functor mechanic.

Supports lambdas. Mutable mechanic auto-filter version.

Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor argument types by default.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
MechanicThe functor mechanic to operate with. Can be a lambda expression.
Returns
The status of the operation.

◆ OperateConcurrently() [1/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( const MechanicT &  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the mechanism using a functor mechanic in a threaded manner.

Supports lambdas. Constant mechanic auto-filter version.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor's argument types by default.
ParadigmThe security paradigm to utilize.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
MechanicThe functor mechanic to operate with. Can be a lambda expression.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ OperateConcurrently() [2/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( FilterT &&  Filter,
const MechanicT &  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the mechanism using a functor mechanic in a threaded manner.

Supports lambdas. Constant mechanic version.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor's argument types by default.
ParadigmThe security paradigm to utilize.
FilterTThe type of filter to query with.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
FilterThe filter to query with.
MechanicThe functor mechanic to operate with. Can be a lambda expression.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ OperateConcurrently() [3/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( FilterT &&  Filter,
FunctionT *const  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the chain using a free function mechanic in a parallel manner.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on function's argument types by default.
ParadigmThe security paradigm to utilize.
FilterTThe type of filter to query with.
FunctionTThe type of the mechanic function to operate on the slots.
Parameters
FilterThe filter to query with.
MechanicThe mechanical function to operate with.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ OperateConcurrently() [4/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FilterT = void, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value &&std::is_base_of< FFilterIndicator, FilterT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( FilterT &&  Filter,
MechanicT &  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the mechanism using a functor mechanic in a threaded manner.

Supports lambdas. Mutable mechanic version.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor's argument types by default.
ParadigmThe security paradigm to utilize.
FilterTThe type of filter to query with.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
FilterThe filter to query with.
MechanicThe functor mechanic to operate with. Can be a lambda expression.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ OperateConcurrently() [5/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename FunctionT = void>
std::enable_if< std::is_function< FunctionT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( FunctionT *const  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the chain using a free function mechanic in a parallel manner.

Auto-filter version.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on function's argument types by default.
ParadigmThe security paradigm to utilize.
FunctionTThe type of the mechanic function to operate on the slots.
Parameters
MechanicThe mechanical function to operate with.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ OperateConcurrently() [6/6]

template<typename ChainT = void, EParadigm Paradigm = EParadigm::None, typename MechanicT = void>
std::enable_if<!std::is_function< MechanicT >::value, EApparatusStatus >::type IMechanical::OperateConcurrently ( MechanicT &  Mechanic,
const int32  ThreadsCountMax,
const int32  SlotsPerThreadMin = 1,
const bool  bSync = true 
)

Process the mechanism using a functor mechanic in a threaded manner.

Supports lambdas. Mutable mechanic auto-filter version.

Note
Only solid chains can be safely operated concurrently.
Template Parameters
ChainTThe type of chain to utilize. Detected automatically based on functor's argument types by default.
ParadigmThe security paradigm to utilize.
MechanicTThe type of the functor to operate on the enchained slots. Can be a lambda expression.
Parameters
MechanicThe functor mechanic to operate with. Can be a lambda expression.
ThreadsCountMaxThe maximum number of threads to process with.
SlotsPerThreadMinThe minimum number of slots per thread to process.
bSyncShould the operation be synced within the current branch.
Returns
The status of the operation.

◆ PresentationTick()

virtual void IMechanical::PresentationTick ( float  DeltaSeconds,
float  FrameRatio,
float  FutureFactor 
)
inlinevirtual

Process a past-steady presentation tick.

Parameters
DeltaSecondsThe fixed delta time in seconds.
FrameRatioThe steady frame ratio.
FutureFactorThe steady future factor.

◆ ReceiveBoot()

void IMechanical::ReceiveBoot ( )

Process newly created subjects.

◆ ReceiveInputTick()

void IMechanical::ReceiveInputTick ( )

Process a pre-steady input tick.

◆ ReceivePresentationTick()

void IMechanical::ReceivePresentationTick ( float  DeltaSeconds,
float  FrameRatio,
float  FutureFactor 
)

Process a past-steady presentation tick.

Parameters
DeltaSecondsThe fixed delta time in seconds.
FrameRatioThe steady frame ratio.
FutureFactorThe steady future factor.

◆ ReceiveSteadyTick()

void IMechanical::ReceiveSteadyTick ( float  DeltaSeconds)

Process a fixed-rate steady tick.

◆ SpawnSubject()

FSubjectHandle IMechanical::SpawnSubject ( const EFlagmark  Flagmark = FM_None)

Spawn a new subject, returning its handle.

Parameters
FlagmarkThe initial flagmark of the subject to spawn with.

◆ SteadyTick()

virtual void IMechanical::SteadyTick ( float  DeltaTime)
inlinevirtual

Process a fixed-rate steady tick.

Friends And Related Function Documentation

◆ UMachine

friend class UMachine
friend

Member Data Documentation

◆ bInsidePresentationTick

uint32 IMechanical::bInsidePresentationTick
protected

Is this mechanism currently in the process of presentation ticking?

◆ bInsideSteadyTick

uint32 IMechanical::bInsideSteadyTick
protected

Is this mechanism currently in the process of steady ticking?

◆ bInsideTick

uint32 IMechanical::bInsideTick
protected

Is this mechanism currently updating?

◆ PrevTime

float IMechanical::PrevTime = NAN
protected

The game time of the previous tick.

◆ ProcessedSteadyFrame

int64 IMechanical::ProcessedSteadyFrame = -1
protected

The last, actually processed steady frame.

-1 if the steady tick was not run yet.

◆ SteadyFrame

int64 IMechanical::SteadyFrame = 0
protected

The steady frame we are currently part of.


The documentation for this class was generated from the following file: