UE::EConsumeAllMpmcQueueResult

Navigation

API > API/Runtime > API/Runtime/Core > API/Runtime/Core/Containers

References

Syntax

namespace UE  
{  
    enum EConsumeAllMpmcQueueResult  
    &123;  
        HadItems,  
        WasEmpty,  
    &125;  
}  
Copy full snippet

namespace UE {     enum EConsumeAllMpmcQueueResult     &123;         HadItems,         WasEmpty,     &125; }

Values

Remarks

Insights.

predeclarations

Work around missing header/implementations on some platforms.

Interchange namespace.

predeclare tangents template

only needed if you enable logging by changing the typedef for FConstrainedSolverTimeLogger

Forward declarations.

Includes.

Fwd declare ELLMTag.

Move out of global namespace to avoid collisions with Chaos::TVector within the physics code.

LWCConversion helpers.

Implements a rectangular 2D Box.

Structure for a combined axis aligned bounding box and bounding sphere with the same origin. (28 bytes).

Structure for capsules.

A capsule consists of two sphere connected by a cylinder.

Dual quaternion class

4x4 matrix of floating point values. Matrix-matrix multiplication happens with a pre-multiple of the transpose in other words, Res = Mat1.operator*(Mat2) means Res = Mat2^FArg * Mat1, as opposed to Res = Mat1 * Mat2. Matrix elements are accessed with M[RowIndex][ColumnIndex].

Copyright Epic Games, Inc. All Rights Reserved. Copyright Epic Games, Inc. All Rights Reserved. Structure for three dimensional planes.

Stores the coeffecients as Xx+Yy+Zz=W. Note that this is different from many other Plane classes that use Xx+Yy+Zz+W=0.

3D Ray represented by Origin and (normalized) Direction

Implements a basic sphere.

Include the current implementation of a FTransform, depending on the vector processing mode

Adapters for TVector2.

Since it is an existing UE4 types, we cannot rely on the default template that calls member functions. Instead, we provide direct overloads.

Concatenate overloads.

Since these are existing UE4 types, we cannot rely on the default template that calls member functions. Instead, we provide direct overloads.

TVector2 inline functions

A vector in 2-D space composed of components (X, Y) with floating point precision.

Fwd declare LLM private tag data

should we start putting the code in the UE namespace? Inertialization: High-Performance Animation Transitions in 'Gears of War' David Bollo Game Developer Conference 2018

https://www.gdcvault.com/play/1025165/Inertializationhttps://www.gdcvault.com/play/1025331/Inertialization

Code for reading .shk files and using that information to map shader hashes back to human-readable identifies.

Implements a visitor pattern to allow external code to easily iterate through a sequence hierarchy, running custom code for each track, object, sub-section, or section visited. This handles skipping over non-evaluated sub-scenes as well as accumulation of clamp ranges and sequence transforms as it iterates through the hierarchy. This does not currently support looping (only visits once, though FSubSequenceSpace::LocalClampRange will be the range of all the loops).

Example:

using FCameraCutInfo = TTuple; struct FCameraCutVisitor : UE::MovieScene::ISequenceVisitor { virtual void VisitTrack(UMovieSceneTrack* InTrack, const FGuid&, const UE::MovieScene::FSubSequenceSpace& LocalSpace) { if (UMovieSceneCameraCutTrack* CameraCutTrack = Cast(InTrack)) { for (UMovieSceneSection* Section : CameraCutTrack->GetAllSections()) { if (!Section->IsActive()) { continue; }

UMovieSceneCameraCutSection* CameraCutSection = CastChecked(Section); TRange RootCameraRange = TRange::Intersection(LocalSpace.RootClampRange, CameraCutSection->GetRange() * LocalSpace.RootToSequenceTransform.InverseLinearOnly()); if (!RootCameraRange.IsEmpty()) { CameraCutTree.Add(RootCameraRange, MakeTuple(CameraCutSection, LocalSpace.SequenceID, LocalSpace.HierarchicalBias)); } } } } TMovieSceneEvaluationTree CameraCutTree; };

UE::MovieScene::FSequenceVisitParams Params; Params.bVisitRootTracks = true; Params.bVisitSubSequences = true; FCameraCutVisitor CameraCutVisitor;

// Visit all camera cuts VisitSequence(InSequence, Params, CameraCutVisitor);

Implementation of custom blend logic should be as follows (using doubles as an example). Specializing TBlendableTokenTraits for a particular input data type causes WorkingDataType to be used during the blending operation. Where WorkingDataType belongs to a namespace, ADL will be employed to discover any relevant overloads for BlendValue that match the necessary types. This allows blending of any arbitrary type into the WorkingDataType.

namespace MovieScene { / Define a custom namespaced type that will be used to calculate blends between doubles struct FBlendableDouble { FBlendableDouble() : AbsoluteTotal(0.0), AdditiveTotal(0.0) {}

double AbsoluteTotal; double AdditiveTotal;

TOptional TotalWeight;

double Resolve(TMovieSceneInitialValueStore& InitialValueStore) { if (TotalWeight.IsSet()) { if (TotalWeight.GetValue() == 0.f) { AbsoluteTotal = InitialValueStore.GetInitialValue(); } else { AbsoluteTotal /= TotalWeight.GetValue(); } }

return AbsoluteTotal + AdditiveTotal; } };

void BlendValue(FBlendableDouble& OutBlend, double InValue, float Weight, EMovieSceneBlendType BlendType, TMovieSceneInitialValueStore& InitialValueStore) { if (BlendType == EMovieSceneBlendType::Absolute || BlendType == EMovieSceneBlendType::Relative) { if (BlendType == EMovieSceneBlendType::Relative) { OutBlend.AbsoluteTotal += (InitialValueStore.GetInitialValue() + InValue) * Weight; } else { OutBlend.AbsoluteTotal += InValue * Weight; }

OutBlend.TotalWeight = OutBlend.TotalWeight.Get(0.f) + Weight; } else if (BlendType == EMovieSceneBlendType::Additive) { OutBlend.AdditiveTotal += InValue * Weight; } } } template<> struct TBlendableTokenTraits { typedef UE::MovieScene::FBlendableDouble WorkingDataType; };

~ Generic multi-channel blending support for sequencer. Works in conjunction with TMovieSceneBlendingActuator where Type has been set up with the correct traits to allow multi-channel blending: Example:

// My struct contains 3 floats, so is represented as a TMultiChannelValue struct FMyStruct { float X, Y, Z; ... };

namespace MovieScene { // Marshall my struct into a multi-channel value inline void MultiChannelFromData(FMyStruct In, TMultiChannelValue& Out) { Out = { In.X, In.Y, In.Z }; } // Marshall my struct out of a static float array inline void ResolveChannelsToData(float (&Channels)[3], FMyStruct& Out) { Out = FMyStruct(Channels[0], Channels[1], Channels[2]); } }

// Access a unique runtime type identifier for FMyStruct. Implemented in cpp to ensure there is only ever 1. This is required to support actuators operating on FMyStructs. template<> FMovieSceneAnimTypeIDGetBlendingDataType();

// Inform the blending code to use a maksed blendable of 3 floats for my struct template<> struct TBlendableTokenTraits { typedef UE::MovieScene::TMaskedBlendable WorkingDataType; };

// To inject a blendable token into the accumulator for an FMyStruct: UE::MovieScene::TMultiChannelValue AnimatedData;

// Set the X and Z channels AnimatedData.Set(0, 100.f); AnimatedData.Set(2, 250.f);

// Ensure the accumulator knows how to apply an FMyStruct (usually this will be on a property, and happen through EnsureActuator<>) FMovieSceneBlendingActuatorID ActuatorTypeID = FMyActuatorType::GetActuatorTypeID(); if (!ExecutionTokens.GetAccumulator().FindActuator(ActuatorTypeID)) { ExecutionTokens.GetAccumulator().DefineActuator(ActuatorTypeID, MakeShared()); }

// Add the blendable to the accumulator float Weight = EvaluateEasing(Context.GetTime()); // Constructing a TBlendableToken from any type other than TMultiChannelValue requires a supporting BlendValue function ExecutionTokens.BlendToken(ActuatorTypeID, TBlendableToken(AnimatedData, EMovieSceneBlendType::Absolute, Weight));

The above macros will not work if no other header that defines the UE::Geometry:: namespace has been #included, this declaraction resolves that problem.

Very approximately ported from geometry3sharp's PlanarComplex Convert a set of polygons into general polygon form, tracking the outer-polygon and hole-polygon indices

Port of geometry3Sharp DistLine3Segment3 which was ported from WildMagic 5

Port of geometry3Sharp DistLine3Triangle3 which was ported from WildMagic 5

Port of geometry3Sharp DistSegment3Triangle3 which was ported from WildMagic 5

Port of geometry3Sharp DistTriangle3Triangle3 which was ported from WildMagic 5

Implementation of mesh change tracking for FDynamicMesh3.

The top-level class is FDynamicMeshChangeTracker, found at the bottom of this file. You create an instance of this and then call BeginChange(), then call SaveVertex()/SaveTriangle() before you make modifications to a vertex/triangle, and then call EndChange() at the end. This function emits a FDynamicMeshChange instance, and you can call Apply() to apply/revert it. So this is the object you would store in a higher-level undo/redo record, for example.

Attribute overlays make everything more complicated of course. Handling of these follows a similar structure - the MeshChangeTracker creates a FDynamicMeshAttributeSetChangeTracker, which in turn creates a TDynamicMeshAttributeChange for each UV and Normal overlay (grouped together in a FDynamicMeshAttributeChangeSet). However you don't have to explicitly do anything to get Attribute support, if the initial Mesh had attributes, then this all happens automatically, and the attribute changes get attached to the FDynamicMeshChange.

Utility functions for constructing various PointSetAdapter and MeshAdapter instances from dynamic meshes

Utility functions for manipulating DynamicMesh attribute sets

Landscape GPU culling implementation Each landscape section is split to a smaller tiles (4x4 quads) Tiles are frustum culled in compute Culling is done for each view, including shadow views Only active for LOD0 atm

Copyright Epic Games, Inc. All Rights Reserved. Port of geometry3Sharp MinimalHoleFiller

Utility functions for applying transformations to meshes

UE::ToolTarget:: namespace contains utility/helper functions for interacting with UToolTargets. Generally these are meant to be used by UInteractiveTools to handle standard tasks that would otherwise require each Tool to figure out things like which ToolTargetInterface to cast to, etc. Using these functions ideally avoids all the boilerplate inherent in the ToolTarget system.

However, the cost is that it is not necessarily the most efficient, as each one of these functions may potentially do many repeated Cast<>'s internally. So, use sparingly, or cache the outputs.

internal Utility function to render the given Scene to a render target and capture one of the render buffers, defined by VisualizationMode. Not clear where the valid VisualizationMode FNames are defined, possibly this list: "BaseColor,Specular,SubsurfaceColor,WorldNormal,SeparateTranslucencyRGB,,,WorldTangent,SeparateTranslucencyA,,,Opacity,SceneDepth,Roughness,Metallic,ShadingModel,,SceneDepthWorldUnits,SceneColor,PreTonemapHDRColor,PostTonemapHDRColor"

Utility functions for Tool implementations to use to work with Stored Selections

This is an internal singleton used to support UDynamicMesh::ExportCustomProperties() and UDynamicMesh::ImportCustomProperties() below.

Port of geometry3Sharp DistLine3Circle3 which was ported from WildMagic 5

Enums related to the PacketHandler

Forward declarations

double is a 64 bit IEEE 754 double precision Floating Point Number 1 bit for the sign, 11 bits for the exponent, and 52* bits for the value 15.5 decimal digits of precision (max value*: 4503_599627_370495) |--------------------------------------------------------------------------- | 900000.000_000001 --> up to 10 days with 1 ns precision | 90_000.000000_0001 --> up to 25 hours with 0.1 ns precision (100 ps) | 9_000.000000_00001 --> up to 2.5 hours with 0.01 ns precision (10 ps) | 900.000_000000_001 > up to 15 min with 1 ps precision |--------------------------------------------------------------------------- | 3600.000_000000_001 > 1 ps precision at 1 hour : NOT OK (16 digits)!!! | 86400.000_000000_001 > 1 ps precision at 1 day : NOT OK (17 digits)!!! |---------------------------------------------------------------------------

Implementation of "Isosurface Stuffing: Fast Tetrahedral Meshes with Good Dihedral Angles" By Francois Labelle and Jonathan Richard Shewchuk https://people.eecs.berkeley.edu/~jrs/papers/stuffing.pdf