description: true if a list has been allocated at the given ListIndex

code: bool IsAllocated ( int32 ListIndex ) const


module: GeometryCore

code: MappedValueEnumerable &40; const FSmallListSet &42; ListSetIn, int32 ListIndex, TFunction< int32(int32)> MapFunc &41;


className: MappedValueEnumerable

description: MappedValueEnumerableis an object that provides begin/end semantics for a small list, suitable for use with a range-based for loop

code: class MappedValueEnumerable

ListSet

type: constFSmallLis...

MapFunc

type: TFunction< int3...


code: int32 operator&42;&40;&41; const


code: const MappedValueIterator & operator&43;&43;&40;&41;


code: MappedValueIterator &40; const FSmallListSet &42; ListSetIn, int32 ListIndex, bool is_end, TFunction< int32(int32)> MapFuncIn &41;


description: a value enumerable for the given ListIndex, with the given value mapping function

code: [MappedValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\MappedValueEnumerable) MappedValues ( int32 ListIndex, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< int32(int32)> MapFunc ) const


className: MappedValueIterator

description: MappedValueIteratoriterates over the values of a small list An optional mapping function can be provided which will then be applied to the values returned by the * operator

code: class MappedValueIterator : public [UE::Geometry::FSmallListSet::BaseValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\BaseValueIterator)


description: Move list at FromIndex to ToIndex

code: void Move ( int32 FromIndex, int32 ToIndex )


description:
Remove Value from the list at ListIndex
false if Value was not in this list

code: bool Remove ( int32 ListIndex, int32 Value )


className: NullValue

description: This value is used to indicate Null in internal pointers

code: static const int32 NullValue = -1;


description: Remove val from the linked-list attached to block_ptr

code: bool RemoveFromLinkedList ( int32 block_ptr, int32 val )


description: Reset to initial state

code: void Reset()


description: Set new number of lists

code: void Resize ( int32 NewSize )


description: SerializeFSmallListSetto an archive.

code: void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, bool bCompactData, bool bUseCompression )


description: largest current list index

code: size_t Size() const


code: ValueEnumerable &40; const FSmallListSet &42; ListSetIn, int32 ListIndex &41;


description:
Search the list at ListIndex for a value where PredicateFunc(value) returns true, and replace it with NewValue
true if the value was found and replaced

code: bool Replace ( int32 ListIndex, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32)> & PredicateFunc, int32 NewValue )


className: ValueEnumerable

description: ValueEnumerableis an object that provides begin/end semantics for a small list, suitable for use with a range-based for loop

code: class ValueEnumerable


code: const ValueIterator & operator&43;&43;&40;&41;


code: ValueIterator &40; const FSmallListSet &42; ListSetIn, int32 ListIndex, bool is_end &41;


className: ValueIterator

description: ValueIteratoriterates over the values of a small list

code: class ValueIterator : public [UE::Geometry::FSmallListSet::BaseValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\BaseValueIterator)


description: a value enumerable for the given ListIndex

code: [ValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\ValueEnumerable) Values ( int32 ListIndex ) const


className: FSmallListSet

description: Each list stores its count, so list-size operations are constant time. All the internal "pointers" are 32-bit.

code: class FSmallListSet

AllocatedCount

description: Number of allocated lists

FreeBlocks

type: TDynamicVector<...

description: List of free blocks as indices/offsets into ListBlocks

FreeHeadIndex

description: Index of first free element in linked_store

LinkedListElements

description: Flat buffer used to store linked-list "spill" elements each element is [value, next_ptr]

ListBlocks

description: Flat buffer used to store per-list linear-memory blocks.

ListHeads

description: Mapping from list index to offset into ListBlocks that contains list data


description: Add the members of the current index set to an object that supports .Reserve(int) and .Add(int)

code: template<typename ArrayType> void Collect ( ArrayType & Storage ) const


description: Range-for support. Do not directly call these functions.

code: [TArray](API\Runtime\Core\Containers\TArray)< int32 >::RangedForConstIteratorType begin() const


description: true ifIndexis in the current set

code: bool Contains ( int32 Index ) const


code: [TArray](API\Runtime\Core\Containers\TArray)< int32 >::RangedForConstIteratorType end() const


description: array of unique indices

code: const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Indices() const


description: Initialize the set with maximum index.

code: void Initialize ( int32 MaxIndexIn, int32 MaxValuesHint )


description: number of indices in set

code: const int32 Num() const


description: the internalTArray. After calling this, the set is invalid and needs to beInitialize()'d again

code: [TArray](API\Runtime\Core\Containers\TArray)< int32 > && TakeValues()


description: TODO: second bit set that tracks which blocks of ints have been set. This would allow for clears to be much quicker for subsets. (would want to profile to see that it helps, but the bit set is still 0.125mb per million indices, which isn't a trivial amount to set to zero...) TODO: alternately, use aTSetinstead of Bits array if we know that the number of values we are going to add is very small? This would avoid clears.

code: ~FUniqueIndexSet()


className: FUniqueIndexSet

description: This is faster for construction than aTSet, but does require allocating and/or clearing the bit-array. Still generally quite a bit more efficient, particularly for large sets.

code: class FUniqueIndexSet

Bits

type: int64 *

Values

type: TArray< int32 >


description: AddIndexto the set

code: bool Add ( int32 Index )


description: Replace Val with MapFunc[Val] using index operator

code: namespace IndexUtil { template<typename Func> void IndexUtil::ApplyMap ( [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & Val, Func MapFunc ) }


code: namespace IndexUtil { template<typename T, typename Func> void IndexUtil::ApplyMap ( [TVector](API\Runtime\Core\Math\TVector)< T > & Val, Func MapFunc ) }


description: MapFunc[Val] using index operator

code: namespace IndexUtil { template<typename T, typename Func> [TVector](API\Runtime\Core\Math\TVector)< T > IndexUtil::ApplyMap ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Val, Func MapFunc ) }


description: MapFunc[Val] using index operator

code: namespace IndexUtil { template<typename Func> [FIndex3i](API\Runtime\GeometryCore\FIndex3i) IndexUtil::ApplyMap ( const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & Val, Func MapFunc ) }


description: false if CheckFn returns false on any element of ToCheck, true otherwise

code: namespace IndexUtil { template<typename T, typename Func> bool IndexUtil::ArrayCheck ( const [TArray](API\Runtime\Core\Containers\TArray)< T > & ToCheck, Func CheckFn ) }


description:
Find unordered edge [VertexID1,VertexID2] in TriangleVerts
index in range 0-2, or InvalidID if not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindEdgeIndexInTri ( T VertexID1, T VertexID2, const Vec & TriangleVerts ) }


description: Swap the internalTArraywith anotherTArray. After calling this, the set is invalid and needs to beInitialize()'d again

code: void SwapValuesWith ( [TArray](API\Runtime\Core\Containers\TArray)< int32 > & OtherArray )


description: the vertex in the pair ev that is not v, or InvalidID if not found

code: namespace IndexUtil { int IndexUtil::FindEdgeOtherVertex ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & EdgeVerts, int VertexID ) }


description: the vertex that is the same in both EdgeVerts1 and EdgeVerts2, or InvalidID if not found

code: namespace IndexUtil { int IndexUtil::FindSharedEdgeVertex ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & EdgeVerts1, const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & EdgeVerts2 ) }


description:
Find ordered edge [VertexID1,VertexID2] in TriangleVerts
index in range 0-2, or InvalidID if not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindTriOrderedEdge ( T VertexID1, T VertexID2, const Vec & TriangleVerts ) }


description:
Find ordered edge [VertexID1,VertexID2] in TriangleVerts and then return the index of the remaining third vertex
index of third vertex, or InvalidID if not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindTriOtherIndex ( T VertexID1, T VertexID2, const Vec & TriangleVerts ) }


description:
Find ordered edge [VertexID1,VertexID2] in TriangleVerts and then return the remaining third vertex
vertex id of other vertex, or InvalidID if not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindTriOtherVtx ( T VertexID1, T VertexID2, const Vec & TriangleVerts ) }


description:
Find ordered edge [VertexID1,VertexID2] in a triangle that is in an array of triangles, and return remaining third vertex
vertex id of other vertex, or InvalidID if not found

code: namespace IndexUtil { int IndexUtil::FindTriOtherVtx ( int VertexID1, int VertexID2, const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > & TriIndexArray, int TriangleIndex ) }


description:
Find third vertex of triangle that is not VertexID1 or VertexID2. Triangle must contain VertexID1 and VertexID2 or result will be incorrect.
VertexID of third vertex, or incorrect result if precondition is not met

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindTriOtherVtxUnsafe ( T VertexID1, T VertexID2, const Vec & TriangleVerts ) }


description: If i0 and i1 are unordered indices into a triangle, each in range 0-2, return the third index

code: namespace IndexUtil { int IndexUtil::GetOtherTriIndex ( int i0, int i1 ) }


description:
result is garbage if either vertex is not an edge in TriangleVerts
true if order was swapped

code: namespace IndexUtil { template<typename T, typename Vec> bool IndexUtil::OrientTriEdge ( T & Vertex1, T & Vertex2, const Vec & TriangleVerts ) }


description:
Assuming [Vertex1,Vertex2] is an unordered edge in TriangleVerts, return Vertex1 and Vertex2 in the correct order (ie the same as TriangleVerts), and returns the vertex ID of the other vertex
ID of third vertex, or InvalidID if the edge was not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::OrientTriEdgeAndFindOtherVtx ( T & Vertex1, T & Vertex2, const Vec & TriangleVerts ) }


description: true if [a0,a1] and [b0,b1] are the same pair, ignoring order

code: namespace IndexUtil { template<typename T> bool IndexUtil::SamePairUnordered ( T a0, T a1, T b0, T b1 ) }


description: index 0/1/2 of VertexID in TriangleVerts, or InvalidID if not found

code: namespace IndexUtil { template<typename T, typename Vec> int IndexUtil::FindTriIndex ( T VertexID, const Vec & TriangleVerts ) }


code: bool operator== ( const [MappedIterator](API\Runtime\GeometryCore\Util\MappedIterator) & Other ) const


className: MapFunctionT

code: typedef [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< ToType(FromType)> MapFunctionT


code: bool operator!= ( const [MappedIterator](API\Runtime\GeometryCore\Util\MappedIterator) & Other ) const


code: const [MappedIterator](API\Runtime\GeometryCore\Util\MappedIterator) & operator++()


code: MappedIterator ( const IteratorT & CurItr, const [MapFunctionT](API\Runtime\Core\GenericPlatform\TFunction) & MapFunctionIn )


className: MappedIterator

description: Conversion is done via a provided mapping function

code: template<typename FromType, typename ToType, typename IteratorT> class MappedIterator

Cur

type: IteratorT

MapFunction

type: MapFunctionT


description: Generates a sweep curve with the initial frame at the origin and the rest rotated around the given axis.

code: namespace RevolveUtil { GEOMETRYCORE_API void RevolveUtil::GenerateSweepCurve ( const FVector3d & RevolutionAxisOrigin, const FVector3d & RevolutionAxisDirection, double DegreesOffset, double DegreesPerStep, double DownAxisOffset, int TotalNumFrames, [TArray](API\Runtime\Core\Containers\TArray)< [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) > & SweepCurveOut ) }


description: Shifts the profile curve in such a way that it becomes the midpoint of the first rotation step (i.e., rotates it back half a step while projecting it outward onto the plane passing through the profile).

code: namespace RevolveUtil { GEOMETRYCORE_API void RevolveUtil::MakeProfileCurveMidpointOfFirstStep ( [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & ProfileCurve, double DegreesPerStep, const FVector3d & RevolutionAxisOrigin, const FVector3d & RevolutionAxisDirection ) }


description: Results are undefined if a fully revolved mesh would be self intersecting. Assumes that RevolutionAxisDirection is normalized.

code: namespace RevolveUtil { GEOMETRYCORE_API bool RevolveUtil::ProfileIsCCWRelativeRevolve ( [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & ProfileCurve, const FVector3d & RevolutionAxisOrigin, const FVector3d & RevolutionAxisDirection, bool bProfileCurveIsClosed ) }


description: Assumes that RevolutionAxisDirection is normalized.

code: namespace RevolveUtil { GEOMETRYCORE_API void RevolveUtil::WeldPointsOnAxis ( [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & ProfileCurve, const FVector3d & RevolutionAxisOrigin, const FVector3d & RevolutionAxisDirection, double Tolerance, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & ProfileVerticesToWeldOut ) }


code: static [FVector3i](API\Runtime\GeometryCore\FVector3i) CeilInt ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V )


code: TBoundsGridIndexer3 ( const [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > & Bounds, RealType CellSize )


code: template<typename RealType> struct TBoundsGridIndexer3 : public [UE::Geometry::TShiftGridIndexer3< RealType >](API\Runtime\GeometryCore\Util\TShiftGridIndexer3)

BoundsMax

type: TVector< RealTy...


code: void Add ( const Type & Data )


code: void Add ( const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) & Data )


description: Apply f() to each member sequentially

code: template<typename Func> void Apply ( const Func & f )


description: iterator at beginning of vector


className: BlockIndexBitmask

code: static constexpr int BlockIndexBitmask = BlockSize - 1;


className: BlockSize

code: static constexpr int BlockSize = 1 << nShiftBits;


className: BlockType

code: typedef [TStaticArray](API\Runtime\Core\Containers\TStaticArray)< Type, BlockSize > BlockType


code: Type & ElementAt ( unsigned int Index, Type InitialValue )


description: iterator at end of vector


code: bool operator&33;&61; &40; const FConstIterator & Itr2 &41; const


code: const Type & operator&42;&40;&41; const


code: FConstIterator operator&43;&43; &40; int &41;


className: FConstIterator

description: No constructors are accessible with public or protected access.

code: class FConstIterator


code: void Fill ( const Type & Value )


code: bool operator&61;&61; &40; const FIterator & Itr2 &41; const


code: bool operator&61;&61; &40; const FConstIterator & Itr2 &41; const


code: bool operator&33;&61; &40; const FIterator & Itr2 &41; const


code: FIterator operator&43;&43; &40; int &41;


code: FIterator & operator&43;&43;&40;&41;


className: FIterator

code: class FIterator


code: void InsertAt ( const Type & Data, unsigned int Index )


code: void InsertAt ( const Type & Data, unsigned int Index, const Type & InitValue )


className: MaxBlockCount

code: static constexpr unsigned int MaxBlockCount = MaxSize / BlockSize + 1;


className: nShiftBits

code: static constexpr int nShiftBits = 9;


className: MaxSize

code: static constexpr uint32 MaxSize = ((uint32) 0xffffffff);


code: [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) & operator= ( const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) & Copy )


code: [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) & operator= ( [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) && Moved )


code: Type & operator[] ( unsigned int Index )


code: const Type & operator[] ( unsigned int Index ) const


code: void Resize ( unsigned int Count )


code: void Resize ( unsigned int Count, const Type & InitValue )


description: Serialize vector to and from an archive

code: template<bool bForceBulkSerialization, bool bUseCompression> void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


description: Resize ifNum()is less than Count; returns true if resize occurred.

code: bool SetMinimumSize ( unsigned int Count, const Type & InitValue )


code: void SetNum ( unsigned int Count )


code: TDynamicVector ( const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) & Copy )


code: TDynamicVector ( [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector) && Moved )


code: TDynamicVector ( const [TArray](API\Runtime\Core\Containers\TArray)< Type > & Array )


code: TDynamicVector ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const Type > Array )


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< float, 2 > TDynamicVector2f


className: TDynamicVector

description: Iterator functions suitable for use with range-based for are provided

code: template<class Type> class TDynamicVector


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< double, 2 > TDynamicVector2d


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< int, 2 > TDynamicVector2i


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< double, 3 > TDynamicVector3d


code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) AsIndex2 ( unsigned int TopIndex ) const


code: void Add ( const [ElementVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN\ElementVectorN) & AddData )


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< int, 3 > TDynamicVector3i


code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) AsIndex3 ( unsigned int TopIndex ) const


code: [TVector](API\Runtime\Core\Math\TVector)< Type > AsVector3 ( unsigned int TopIndex ) const


code: [FIndex4i](API\Runtime\GeometryCore\FIndex4i) AsIndex4 ( unsigned int TopIndex ) const


code: [TVector2](API\Runtime\Core\Math\TVector2)< Type > AsVector2 ( unsigned int TopIndex ) const


code: typedef [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN)< float, 3 > TDynamicVector3f


className: ElementVectorN

description: Simple struct to help pass N-dimensional data without presuming a vector type (e.g. just via initializer list)

code: struct ElementVectorN

Data

type: Type[N]


code: void Fill ( const Type & Value )


code: void InsertAt ( const [ElementVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN\ElementVectorN) & AddData, unsigned int Index )


code: Type & operator() ( unsigned int TopIndex, unsigned int SubIndex )


code: const Type & operator() ( unsigned int TopIndex, unsigned int SubIndex ) const


code: [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) & operator= ( const [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) & Copy )


code: [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) & operator= ( [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) && Moved )


code: void Resize ( unsigned int Count )


code: void Resize ( unsigned int Count, const Type & InitValue )


code: void SetVector2 ( unsigned int TopIndex, const [TVector2](API\Runtime\Core\Math\TVector2)< Type > & V )


code: void SetVector3 ( unsigned int TopIndex, const [TVector](API\Runtime\Core\Math\TVector)< Type > & V )


code: TDynamicVectorN ( const [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) & Copy )


code: TDynamicVectorN ( [TDynamicVectorN](API\Runtime\GeometryCore\Util\TDynamicVectorN) && Moved )


className: TDynamicVectorN

code: template<class Type, int N> class TDynamicVectorN


className: ExpandIteratorT

code: typedef [TPairExpandIterator](API\Runtime\GeometryCore\Util\TPairExpandIterator)< InputIteratorT > ExpandIteratorT


code: template<typename IteratorSource> TPairExpandEnumerable ( const IteratorSource & Source, [ExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) ExpandFuncIn )


code: TPairExpandEnumerable ( const InputIteratorT & BeginIn, const InputIteratorT & EndIn, [ExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) ExpandFuncIn )


className: TPairExpandEnumerable

description: Generic "enumerable" object that provides begin/end semantics for anTPairExpandIteratorsuitable for use with range-based for. You can either provide begin/end iterators, or another "enumerable" object that hasbegin()/end() functions.

code: template<typename InputIteratorT> class TPairExpandEnumerable

BeginItr

type: InputIteratorT

ExpandFunc

type: ExpandFunctionT


code: bool operator== ( const [TPairExpandIterator](API\Runtime\GeometryCore\Util\TPairExpandIterator) & Other ) const


code: bool operator!= ( const [TPairExpandIterator](API\Runtime\GeometryCore\Util\TPairExpandIterator) & Other ) const


code: const [TPairExpandIterator](API\Runtime\GeometryCore\Util\TPairExpandIterator) & operator++()


code: TPairExpandIterator ( const InputIteratorT & CurItr, const InputIteratorT & EndItr, const [PairExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) & PairFuncIn )


description: Convert integer grid coordinates to real-valued point

code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > FromGrid ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & GridPoint ) const


className: TPairExpandIterator

description: This is done via the PairExpandFunctionTTFunction, which returns aFIndex2ifor a given integer. This pair must be either (a,invalid), (a, b), or (invalid, invalid), where invalid is integer < 0

code: template<typename InputIteratorT> class TPairExpandIterator

CurPairI

type: int

PairFunc

type: PairExpandFunct...


description: Convert real-valued point to integer grid coordinates

code: [FVector2i](API\Runtime\GeometryCore\FVector2i) ToGrid ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & P ) const


code: TScaleGridIndexer2 ( RealType CellSize )


description: Convert between integer grid coordinates and scaled real-valued coordinates (ie assumes integer grid origin == real origin)

code: template<typename RealType> struct TScaleGridIndexer2

CellSize

type: RealType

description: Real-valued size of an integer grid cell


code: [FVector3i](API\Runtime\GeometryCore\FVector3i) ToGrid ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & P ) const


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > FromGrid ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & GridPoint ) const


code: TScaleGridIndexer3 ( RealType CellSize )


code: template<typename RealType> struct TScaleGridIndexer3


description: Convert real-valued grid coordinates to real-valued point

code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > FromGrid ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & RealGridPoint ) const


code: TShiftGridIndexer2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & origin, RealType cellSize )


description: Convert between integer grid coordinates and scaled+translated real-valued coordinates

code: template<typename RealType> struct TShiftGridIndexer2

Origin

type: TVector2< RealT...

description: Real-valued origin of grid, position of integer grid origin


code: [FVector2i](API\Runtime\GeometryCore\FVector2i) ToGrid ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Point ) const


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > FromGrid ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & gridpoint ) const


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > FromGrid ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & RealGridPoint ) const


code: [FVector3i](API\Runtime\GeometryCore\FVector3i) ToGrid ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & point ) const


code: TShiftGridIndexer3 ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & origin, RealType cellSize )


code: template<typename RealType> struct TShiftGridIndexer3


description:
Create a list at the given ListIndex
Handle to allocted list that can be used with Insert and SetValues in multi-threaded contexts

code: [FListHandle](API\Runtime\GeometryCore\Util\TSparseListSet\FListHandle) AllocateAt ( int32 ListIndex )


description: Remove all elements from the list at ListIndex

code: void Clear ( int32 ListIndex )


description: Call ApplyFunc on each element of the list at ListIndex

code: template<typename FuncType> void Enumerate ( int32 ListIndex, FuncType Func ) const


className: FListHandle

description: Handle to an allocated list returned byAllocateAt()

code: struct FListHandle

ListRef

type: void *


description: the size of the list at ListIndex

code: int32 GetCount ( int32 ListIndex ) const


description: Insert Value into List at ListIndex

code: void Insert ( int32 ListIndex, ElementType Value )


description:
Search for the given Value in list at ListIndex
true if found

code: bool Contains ( int32 ListIndex, ElementType Value ) const


description: Insert Value into List identified by ListHandle

code: void Insert ( [FListHandle](API\Runtime\GeometryCore\Util\TSparseListSet\FListHandle) ListHandle, ElementType Value )


description: true if a list has been allocated at the given ListIndex

code: bool IsAllocated ( int32 ListIndex ) const


description:
Remove first occurrence of Value from the list at ListIndex
false if Value was not in this list

code: bool Remove ( int32 ListIndex, ElementType Value )


description: Set the values of the List at ListIndex

code: void SetValues ( int32 ListIndex, const [TArray](API\Runtime\Core\Containers\TArray)< ElementType > & Values )


description: Set the values of the List identified by ListHandle

code: void SetValues ( [FListHandle](API\Runtime\GeometryCore\Util\TSparseListSet\FListHandle) ListHandle, const [TArray](API\Runtime\Core\Containers\TArray)< ElementType > & Values )


code: TSparseListSet ( int BlockSizeIn, int BlocksPerChunkIn )


className: TSparseListSet

description: TSparseListSetcan support parallel insertion into the lists. Note however that lists cannot be added (via AllocateAt) while parallel insertion occurs via Insert(Index). To allow for this type of usage,AllocateAt()returns aFListHandlewhich can then be used withInsert()orSetValues()even while otherAllocateAt()calls occur (within a lock).

code: template<typename ElementType> struct TSparseListSet


description: Test that all the arrays have the same given size.

code: bool bHasSize ( int32 Size ) const


code: void SetX ( int32 i, const RealType & Value )


code: void SetXY ( int32 i, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Value )


code: void SetY ( int32 i, const RealType & Value )


code: RealType X ( int32 i ) const


code: void SetZero ( int32 NumElements )


code: RealType Y ( int32 i ) const


code: TVector2Arrays ( int32 Size )


description: Structure-of-Array (SoA) storage for a list of 2-vectors

code: template<typename RealType> class TVector2Arrays

XVector

type: TArray< RealTyp...


code: void Set ( int32 i, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Value )


code: void SetXYZ ( int32 i, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Value )


code: void SetZ ( int32 i, const RealType & Value )


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > Get ( int32 i )


code: RealType Z ( int32 i ) const


code: TVector3Arrays ( int32 Size )


description: Structure-of-Array (SoA) storage for a list of 3-vectors

code: template<typename RealType> class TVector3Arrays


description: EGeometryResultType is a generic result-code for use by geometry operations.

code: namespace UE { namespace Geometry { enum EGeometryResultType { Success = 0, InProgress = 1, Cancelled = 2, PartialResult = 3, Failure = 4, } } }


description: f1 = f.readlines() for x in f1 : tokens = x.split() colors = tokens[2].split(',') r = float(colors[0]) / 255.0; g = float(colors[1]) / 255.0; b = float(colors[2]) / 255.0; print "ColorConstant(" + tokens[0].capitalize() + ", " + str(r) + "f, " + str(g) + "f, " + str(b) + "f);"

code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::AliceBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::AliceBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::AntiqueWhite3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::AntiqueWhite3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Aqua3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Aqua3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Aquamarine3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Aquamarine3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Azure3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Azure3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Beige3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Beige3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Bisque3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Bisque3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Black3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Black3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::BlanchedAlmond3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::BlanchedAlmond3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Blue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Blue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::BlueViolet3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::BlueViolet3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Brown3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Brown3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Burlywood3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Burlywood3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::CadetBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::CadetBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Chartreuse3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Chartreuse3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Chocolate3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Chocolate3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Coral3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Coral3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::CornflowerBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::CornflowerBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Cornsilk3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Cornsilk3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Crimson3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Crimson3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Cyan3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Cyan3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkKhaki3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkKhaki3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkMagenta3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkMagenta3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkOliveGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkOliveGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkOrange3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkOrange3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkOrchid3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkOrchid3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkCyan3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkSalmon3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkSalmon3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkSeagreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkSeagreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkSlateBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkSlateBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkSlateGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkSlateGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkCyan3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkTurquoise3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkTurquoise3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkViolet3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkViolet3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkGoldenrod3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkGoldenrod3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DarkGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DeepPink3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DeepSkyBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DeepPink3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DeepSkyBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DimGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DimGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::DodgerBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DodgerBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Firebrick3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Firebrick3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::FloralWhite3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::DarkGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::FloralWhite3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::ForestGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::ForestGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Fuchsia3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Fuchsia3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Gainsboro3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Gainsboro3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::GhostWhite3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::GhostWhite3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Gold3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Gold3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Goldenrod3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Goldenrod3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Gray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Green3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::GreenYellow3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Green3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::GreenYellow3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::HoneyDew3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::HoneyDew3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::HotPink3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::HotPink3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Gray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::IndianRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::IndianRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Indigo3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Indigo3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Ivory3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Ivory3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Khaki3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Khaki3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Lavender3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Lavender3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LavenderBlush3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LavenderBlush3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LawnGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LawnGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LemonChiffon3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LemonChiffon3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightPink3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightPink3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightSalmon3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightSalmon3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightSeaGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightSeaGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightSkyBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightSkyBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightCoral3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightSlateGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightSteelBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightSlateGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightSteelBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightYellow3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightYellow3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightCoral3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightCyan3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightCyan3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightGoldenrod3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightGoldenrod3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LightGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LightGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Lime3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Lime3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::LimeGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::LimeGreen3f() } } }


description: Apply a Linear to sRGB color transformation on a given color vector.

code: namespace UE { namespace Geometry { namespace LinearColors { template<typename VectorType> void UE::Geometry::LinearColors::LinearToSRGB ( VectorType & Color ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Linen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Linen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Magenta3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Magenta3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { template<typename VectorType> VectorType UE::Geometry::LinearColors::MakeColor3f ( float R, float G, float B ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { template<typename VectorType> VectorType UE::Geometry::LinearColors::MakeColor4f ( float R, float G, float B, float A ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Maroon3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Maroon3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumAquamarine3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumAquamarine3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumSlateBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumSlateBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumSpringGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumTurquoise3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumSpringGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumTurquoise3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumVioletRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumVioletRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumOrchid3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumOrchid3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumPurple3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MediumSeaGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumPurple3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MidnightBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MediumSeaGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MidnightBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MintCream3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MintCream3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::MistyRose3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Moccasin3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::MistyRose3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Moccasin3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::NavajoWhite3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::NavajoWhite3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Navy3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Navy3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::OldLace3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Olive3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::OldLace3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Olive3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::OliveDrab3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::OliveDrab3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Orange3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Orange3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::OrangeRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Orchid3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::OrangeRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PaleGoldenrod3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Orchid3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PaleGoldenrod3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PaleGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PaleTurquoise3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PaleTurquoise3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PaleGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PaleVioletRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PaleVioletRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PapayaWhip3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PapayaWhip3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PeachPuff3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PeachPuff3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Peru3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Peru3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Pink3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Pink3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Plum3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Plum3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::PowderBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Purple3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::PowderBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Purple3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Red3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::RosyBrown3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Red3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::RosyBrown3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::RoyalBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Salmon3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SaddleBrown3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SaddleBrown3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::RoyalBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Salmon3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SandyBrown3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SeaGreen3f() } } }


description: Select a Color from a fixed color palette based on givenIndexColor selected from a fixed set, or White ifIndex< 0

code: namespace UE { namespace Geometry { namespace LinearColors { template<typename VectorType> VectorType UE::Geometry::LinearColors::SelectColor ( int32 Index ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SeaGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Seashell3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Seashell3b() } } }


description: Select aFColorfrom a fixed color palette based on givenIndexColor selected from a fixed set, or White ifIndex< 0

code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SelectFColor ( int32 Index ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Sienna3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SandyBrown3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Sienna3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Silver3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Silver3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SkyBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SkyBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SlateBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SlateBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SlateGray3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SlateGray3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Snow3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SpringGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Snow3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SpringGreen3f() } } }


description: Apply an sRGB to Linear color transformation on a given color vector.

code: namespace UE { namespace Geometry { namespace LinearColors { template<typename VectorType> void UE::Geometry::LinearColors::SRGBToLinear ( VectorType & Color ) } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::SteelBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Tan3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::SteelBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Tan3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Teal3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Teal3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Thistle3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Thistle3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Tomato3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Tomato3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Turquoise3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Turquoise3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::VideoBlack3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::VideoBlack3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::VideoWhite3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::VideoWhite3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::VideoRed3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::VideoRed3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::VideoGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::VideoGreen3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::VideoBlue3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Violet3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::VideoBlue3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Violet3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::White3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Wheat3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Wheat3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::White3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::WhiteSmoke3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::WhiteSmoke3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::Yellow3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::Yellow3b() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::LinearColors::YellowGreen3f() } } }


code: namespace UE { namespace Geometry { namespace LinearColors { [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::LinearColors::YellowGreen3b() } } }


description: Release all compute meshes that the Pool has allocated, and then release them from the Pool, so that they will be garbage-collected

module: GeometryFramework

code: void FreeAllComputeMeshes()


description: Request a compute mesh from the Pool, which will return a previously-allocated mesh or add and return a new one. If the Pool is disabled, a newUDynamicMeshwill be allocated and returned.


description: Access the compute mesh pool


description: Release all compute meshes that the Pool has allocated

code: void ReleaseAllComputeMeshes()


description: Release a compute mesh back to the Pool

code: bool ReleaseComputeMesh ( [UDynamicMesh](API\Runtime\GeometryFramework\UDynamicMesh) * Mesh )


code: ADynamicMeshActor ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: ADynamicMeshActor

description: ADynamicMeshActoris an Actor that has a USimpleDynamicMeshComponent as it's RootObject.

code: class ADynamicMeshActor : public [AActor](API\Runtime\Engine\GameFramework\AActor)

bEnableComputeMeshPool

type: bool

description: Mesh Pool support.

DynamicMeshComponent

type: TObjectPtr< cla...

DynamicMeshPool

type: TObjectPtr<UDy...

description: The internal Mesh Pool, for use in DynamicMeshActor BPs.


description: Makes the change to the object

code: virtual void Apply ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * Object )


description: Apply embedded DynamicMeshChange to given Mesh. This function is for change-targets to call, when passed aFMeshChangeto apply to a Mesh they own. This allowsFMeshChangesubclasses to customize the change behavior if necessary. The default behavior just forwards the call to DynamicMeshChange->Apply(Mesh, bRevert).

code: virtual void ApplyChangeToMesh ( [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, bool bRevert ) const


description: Reverts change to the object

code: virtual void Revert ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * Object )


description: Describes this change (for debugging)

code: virtual [FString](API\Runtime\Core\Containers\FString) ToString() const


code: FMeshChange ( [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Geometry::FDynamicMeshChange](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshChange) > DynamicMeshChangeIn )


className: FMeshChange

description: FMeshChangerepresents an undoable change to a FDynamicMesh3. Currently only valid to call Apply/Revert when the Object is a one of several components backed by FDynamicMesh:UDynamicMeshComponent,UOctreeDynamicMeshComponent,UPreviewMesh

code: class FMeshChange : public [FToolCommandChange](API\Runtime\InteractiveToolsFramework\FToolCommandChange)

OnChangeAppliedFunc

type: TFunction< void...

description: This function is called on Apply and Revert (last argument is true on Apply)


code: const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< const FDynamicMesh3, ESPMode::ThreadSafe > & GetMesh ( bool bRevert ) const


code: FMeshReplacementChange()


className: FMeshReplacementChange

description: FMeshReplacementChangerepresents an undoablecompletechange to a FDynamicMesh3. Currently only valid to call Apply/Revert when the Object is aUDynamicMeshComponent

code: class FMeshReplacementChange : public [FToolCommandChange](API\Runtime\InteractiveToolsFramework\FToolCommandChange)


className: FMeshVertexChange

description: FMeshVertexChangerepresents an reversible change to a set of vertex positions. Currently only aUDynamicMeshComponenttarget is supported.

code: class FMeshVertexChange : public [FToolCommandChange](API\Runtime\InteractiveToolsFramework\FToolCommandChange)

NewColors

type: TArray< FVector...

Normals

type: TArray< int32 >


code: void SaveOverlayNormals ( const FDynamicMesh3 * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ElementIDs, bool bInitial )


code: void SaveOverlayNormals ( const FDynamicMesh3 * Mesh, const [TSet](API\Runtime\Core\Containers\TSet)< int32 > & ElementIDs, bool bInitial )


code: FMeshReplacementChange ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< const FDynamicMesh3, ESPMode::ThreadSafe > Before, [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< const FDynamicMesh3, ESPMode::ThreadSafe > After )


code: void SaveVertexFinal ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 VertexID )


code: void SaveVertexInitial ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 VertexID )


code: template<typename Enumerable> void SaveVertices ( const FDynamicMesh3 * Mesh, Enumerable Enum, bool bInitial )


code: void UpdateOverlayNormalFinal ( int32 ElementID, const FVector3f & NewNormal )


description: Currently only used in vertex sculpt tool. cannot be used if bSaveColors = true

code: void UpdateVertex ( int32 VertexID, const FVector3d & OldPosition, const FVector3d & NewPosition )


description: Currently only used in element paint tool. Can only be used if bSaveColors=true and bSavePositions=false

code: void UpdateVertexColor ( int32 VertexID, const FVector3f & OldColor, const FVector3f & NewColor )


code: void UpdateVertexFinal ( int32 VertexID, const FVector3d & NewPosition )


code: FMeshVertexChangeBuilder()


code: FMeshVertexChangeBuilder ( EMeshVertexChangeComponents Components )


className: FMeshVertexChangeBuilder

description: FMeshVertexChangeBuildercan be used to construct aFMeshVertexChange.

code: class FMeshVertexChangeBuilder

Change

type: TUniquePtr<FMe...

OnNewVertexSaved

type: TUniqueFunction...

description: If set, this function is called whenever a newly-seen VertexID is saved, parameters are (VertexID,Index) into saved-vertices array

SavedNormalElements

type: TMap< int32, in...


code: void ApplyChange ( const [FMeshChange](API\Runtime\GeometryFramework\Changes\FMeshChange) * Change, bool bRevert )


code: void UpdateOverlayNormal ( int32 ElementID, const FVector3f & OldNormal, const FVector3f & NewNormal )


className: IMeshCommandChangeTarget

description: IMeshCommandChangeTargetis an interface which is used to apply a mesh change

code: class IMeshCommandChangeTarget


className: IMeshReplacementCommandChangeTarget

description: IMeshReplacementCommandChangeTargetis an interface which is used to apply a mesh replacement change


code: void ApplyChange ( const [FMeshReplacementChange](API\Runtime\GeometryFramework\Changes\FMeshReplacementChange) * Change, bool bRevert )


code: void ApplyChange ( const [FMeshVertexChange](API\Runtime\GeometryFramework\Changes\FMeshVertexChange) * Change, bool bRevert )


className: UMeshCommandChangeTarget

code: class UMeshCommandChangeTarget : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


className: IMeshVertexCommandChangeTarget

description: IMeshVertexCommandChangeTargetis an interface which is used to apply aFMeshVertexChange

code: class IMeshVertexCommandChangeTarget


className: UMeshReplacementCommandChangeTarget

code: class UMeshReplacementCommandChangeTarget : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


description: RenderBuffer management Allocates a set of render buffers.FPrimitiveSceneProxywill keep track of these buffers and destroy them on destruction.


description: Draw a single-frameFMeshBatchfor aFMeshRenderBufferSet

code: virtual void DrawBatch ( [FMeshElementCollector](API\Runtime\Engine\FMeshElementCollector) & Collector, const [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) & RenderBuffers, const [FDynamicMeshIndexBuffer32](API\Runtime\Engine\FDynamicMeshIndexBuffer32) & IndexBuffer, [FMaterialRenderProxy](API\Runtime\Engine\Materials\FMaterialRenderProxy) * UseMaterial, bool bWireframe, ESceneDepthPriorityGroup DepthPriority, int ViewIndex, [FDynamicPrimitiveUniformBuffer](API\Runtime\Engine\FDynamicPrimitiveUniformBuffer) & DynamicPrimitiveUniformBuffer ) const


className: UMeshVertexCommandChangeTarget

code: class UMeshVertexCommandChangeTarget : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


description: FBaseDynamicMeshSceneProxyAPI - subclasses must implement these functions Return set of active renderbuffers. Must be implemented by subclass. This is the set of render buffers that will be drawn by GetDynamicMeshElements

code: void GetActiveRenderBufferSets ( [TArray](API\Runtime\Core\Containers\TArray)< [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * > & Buffers ) const


description: Render set of active RenderBuffers returned by GetActiveRenderBufferSets

code: virtual void GetDynamicMeshElements ( const [TArray](API\Runtime\Core\Containers\TArray)< const [FSceneView](API\Runtime\Engine\FSceneView) * > & Views, const [FSceneViewFamily](API\Runtime\Engine\FSceneViewFamily) & ViewFamily, uint32 VisibilityMap, [FMeshElementCollector](API\Runtime\Engine\FMeshElementCollector) & Collector ) const


description: Safe GetMaterial function that will never return nullptr

code: virtual [UMaterialInterface](API\Runtime\Engine\Materials\UMaterialInterface) * GetMaterial ( int32 k ) const


code: [FColor](API\Runtime\Core\Math\FColor) GetOverlayColorAsFColor ( const FDynamicMeshColorOverlay * ColorOverlay, int32 ElementID )


description: FBaseDynamicMeshSceneProxyimplementation If EngineShowFlags request vertex color rendering, returns the appropriate vertex color override material's render proxy. Otherwise returns nullptr.

code: static [FMaterialRenderProxy](API\Runtime\Engine\Materials\FMaterialRenderProxy) * GetEngineVertexColorMaterialProxy ( [FMeshElementCollector](API\Runtime\Engine\FMeshElementCollector) & Collector, const [FEngineShowFlags](API\Runtime\Engine\FEngineShowFlags) & EngineShowFlags, bool bProxyIsSelected, bool bIsHovered )


description: number of active materials

code: virtual int32 GetNumMaterials() const


description: Initialize rendering buffers from given attribute overlays. Creates three vertices per triangle, IE no shared vertices in buffers.

code: template<typename TriangleEnumerable, typename UVOverlayListAllocator> void InitializeBuffersFromOverlays ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int NumTriangles, TriangleEnumerable Enumerable, const [TArray](API\Runtime\Core\Containers\TArray)< const FDynamicMeshUVOverlay *, UVOverlayListAllocator > & UVOverlays, const FDynamicMeshNormalOverlay * NormalOverlay, const FDynamicMeshColorOverlay * ColorOverlay, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int, int, int, const FVector3f &, FVector3f &, FVector3f &)> TangentsFunc, bool bTrackTriangles )


code: template<typename TriangleEnumerable> void InitializeBuffersFromOverlays ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int NumTriangles, TriangleEnumerable Enumerable, const FDynamicMeshUVOverlay * UVOverlay, const FDynamicMeshNormalOverlay * NormalOverlay, const FDynamicMeshColorOverlay * ColorOverlay, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int, int, int, const FVector3f &, FVector3f &, FVector3f &)> TangentsFunc, bool bTrackTriangles )


description: RecomputeRenderBufferTriangleIndexSets re-sorts the existing set of triangles in aFMeshRenderBufferSetinto primary and secondary index buffers. Note that UploadIndexBufferUpdate() must be called after this function!

code: void RecomputeRenderBufferTriangleIndexSets ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh )


description: Explicitly release a set of RenderBuffers

code: virtual void ReleaseRenderBufferSet ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * BufferSet )


description: Filter the triangles in aFMeshRenderBufferSetinto the SecondaryIndexBuffer. Requires that RenderBuffers->Triangles has been initialized.

code: void UpdateSecondaryTriangleBuffer ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, bool bDuplicate )


description: This needs to be called if the set of active materials changes, otherwise the check inFPrimitiveSceneProxy::VerifyUsedMaterial()will fail if an override material is set, if materials change, etc, etc


description: Set whether or not to validate mesh batch materials against the component materials.

code: void SetVerifyUsedMaterials ( const bool bState )


description: Update vertex positions/normals/colors of an existing set of render buffers. Assumes that buffers were created with unshared vertices, ie three vertices per triangle, eg byInitializeBuffersFromOverlays()

code: template<typename TriangleEnumerable> void UpdateVertexBuffersFromOverlays ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int NumTriangles, TriangleEnumerable Enumerable, const FDynamicMeshNormalOverlay * NormalOverlay, const FDynamicMeshColorOverlay * ColorOverlay, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int, int, int, const FVector3f &, FVector3f &, FVector3f &)> TangentsFunc, bool bUpdatePositions, bool bUpdateNormals, bool bUpdateColors )


description: Update vertex uvs of an existing set of render buffers. Assumes that buffers were created with unshared vertices, ie three vertices per triangle, eg byInitializeBuffersFromOverlays()

code: template<typename TriangleEnumerable, typename UVOverlayListAllocator> void UpdateVertexUVBufferFromOverlays ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * RenderBuffers, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 NumTriangles, TriangleEnumerable Enumerable, const [TArray](API\Runtime\Core\Containers\TArray)< const FDynamicMeshUVOverlay *, UVOverlayListAllocator > & UVOverlays )


code: FBaseDynamicMeshSceneProxy ( [UBaseDynamicMeshComponent](API\Runtime\GeometryFramework\Components\UBaseDynamicMeshComponent) * Component )


code: virtual ~FBaseDynamicMeshSceneProxy()


className: FBaseDynamicMeshSceneProxy

description: FBaseDynamicMeshSceneProxyis an abstract base class for a Render Proxy for aUBaseDynamicMeshComponent, where the assumption is that mesh data will be stored inFMeshRenderBufferSetinstances

code: class FBaseDynamicMeshSceneProxy : public [FPrimitiveSceneProxy](API\Runtime\Engine\FPrimitiveSceneProxy)

AllocatedBufferSets

type: TSet<FMeshRend...

description: Set of currently-allocated RenderBuffers.

AllocatedSetsLock

type: FCriticalSectio...

description: Use to control access to AllocatedBufferSets

bApplyVertexColorRemapping

description: If true, VertexColorRemappingFunc is called on Vertex Colors provided from Mesh to remap them to a different color

bEnableRaytracing

description: Control raytracing support

bIgnoreVertexColors

description: If true, vertex colors on the FDynamicMesh will be ignored

bUsePerTriangleColor

description: If true, a per-triangle color is used to set vertex colors

bUsePerTriangleNormals

description: If true, a facet normals are used instead of mesh normals

bUseSecondaryTriBuffers

description: If true, populate secondary buffers using SecondaryTriFilterFunc

ColorSpaceTransformMode

type: EDynamicMeshVer...

description: Color Space Transform/Conversion applied to Vertex Colors provided from Mesh Color Overlay Attribute Color Space Conversion is applied after any Vertex Color Remapping.

ConstantVertexColor

type: FColor

description: Constant color assigned to vertices if no other vertex color is specified

ParentBaseComponent

type: UBaseDynamicMes...

PerTriangleColorFunc

type: TFunction<FCol...

description: Per-triangle color function. Only called if bUsePerTriangleColor=true

SecondaryTriFilterFunc

description: Filter predicate for secondary triangle index buffer. Only called if bUseSecondaryTriBuffers=true

VertexColorRemappingFunc

description: Vertex color remapping function.


description: Enqueue a command on the Render Thread to destroy the passed in buffer set. At this point the buffer set should be considered invalid.

code: static void DestroyRenderBufferSet ( [FMeshRenderBufferSet](API\Runtime\GeometryFramework\Components\FMeshRenderBufferSet) * BufferSet )


description: This function can only be called on the Render Thread

code: void InitOrUpdateResource ( [FRenderResource](API\Runtime\RenderCore\FRenderResource) * Resource )


code: void InvalidateRayTracingData()


description: Deprecated* TransferVertexUpdateToGPU now requires a command list

code: void TransferVertexUpdateToGPU ( bool bPositions, bool bNormals, bool bTexCoords, bool bColors )


description: This can only be called on the Rendering Thread.

code: void TransferVertexUpdateToGPU ( [FRHICommandListBase](API\Runtime\RHI\FRHICommandListBase) & RHICmdList, bool bPositions, bool bNormals, bool bTexCoords, bool bColors )


description: Rebuild raytracing data for current buffers


code: void Upload()


code: void UploadIndexBufferUpdate()


code: void UploadVertexUpdate ( bool bPositions, bool bMeshAttribs, bool bColors )


description: Verify that valid raytracing data is available. This will cause a rebuild of the raytracing data if any of our buffers have been modified. Currently this is called by GetDynamicRayTracingInstances to ensure the RT data is available when needed.

code: void ValidateRayTracingData()


code: FMeshRenderBufferSet ( [ERHIFeatureLevel::Type](API\Runtime\RHI\ERHIFeatureLevel__Type) FeatureLevelType )


code: virtual ~FMeshRenderBufferSet()


className: FMeshRenderBufferSet

description: FMeshRenderBufferSetstores a set of RenderBuffers for a mesh

code: class FMeshRenderBufferSet

bEnableRaytracing

description: Configure whether raytracing should be enabled for this RenderBufferSet

bEnableSecondaryIndexBuffer

description: If secondary index buffer is enabled, we populate this index buffer with additional triangles indexing into the same vertex buffers

BuffersLock

description: In situations where we want toupdatethe existing Vertex orIndexbuffers, we need to synchronize access between the Game and Render threads.

ColorVertexBuffer

type: FColorVertexBuf...

description: The buffer containing the vertex color data.

IndexBuffer

type: FDynamicMeshInd...

description: Triangle indices

Material

type: UMaterialInterf...

description: Material to draw this mesh with

PositionVertexBuffer

type: FPositionVertex...

description: The buffer containing the position vertex data.

SecondaryIndexBuffer

description: Partition or subset of IndexBuffer that indexes into same vertex buffers

StaticMeshVertexBuffer

type: FStaticMeshVert...

description: The buffer containing vertex data.

TriangleCount

type: int

description: Number of triangles in this renderbuffer set.

Triangles

type: TOptional<TArr...

description: Optional list of triangles stored in this buffer.

VertexFactory

type: FLocalVertexFac...

description: Vertex factory


description: Build per-material decomposition, and then split each of those into chunks of at most MaxChunkSize (actual chunk sizes will be highly variable and some may be very small...)

code: static void BuildChunkedDecomposition ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [FComponentMaterialSet](API\Runtime\InteractiveToolsFramework\TargetInterfaces\FComponentMaterialSet) * MaterialSet, [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & Decomp, int32 MaxChunkSize )


description: Build decomposition with one group for each MaterialID of mesh

code: static void BuildMaterialDecomposition ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [FComponentMaterialSet](API\Runtime\InteractiveToolsFramework\TargetInterfaces\FComponentMaterialSet) * MaterialSet, [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & Decomp )


className: FGroup

code: struct FGroup

Triangles

type: TArray< int32 >


code: [FGroup](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition\FGroup) & GetGroup ( int32 Index )


code: const [FGroup](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition\FGroup) & GetGroup ( int32 Index ) const


code: void Initialize ( int32 Count )


code: int32 GetGroupForTriangle ( int32 TriangleID ) const


description: Construct mappings between mesh and groups (eg TriangleToGroupMap)

code: void BuildAssociations ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh )


code: bool IsGroup ( int32 Index ) const


code: [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & operator= ( [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) && )


code: [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & operator= ( const [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & )


description: TArraymember cannot be default-constructed (in this case we just make it NonCopyable)

code: FMeshRenderDecomposition()


description: Movable.

code: FMeshRenderDecomposition ( [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) && )


code: FMeshRenderDecomposition ( const [FMeshRenderDecomposition](API\Runtime\GeometryFramework\Components\FMeshRenderDecomposition) & )