Realtime Mesh Component

https://rmc.triaxis.games/
Admin
Realtime Mesh Component is an Unreal Engine plugin for rendering dynamically created, user-loaded,...
Tokens:17,637
Snippets:293
Trust Score:5.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Add RMC to Build.cs (GitHub)

Source: https://rmc.triaxis.games/installation/index.print

Add this line to your project module's Build.cs file to use the RMC from C++ code when installed from GitHub.

```csharp
RealtimeMeshComponent
```

--------------------------------

### Create a Basic Stream Set

Source: https://rmc.triaxis.games/keyconcepts/stream-set/index.print

Demonstrates how to initialize an empty Stream Set and add streams for position and tangents. Streams can be added to a link pool with default values.

```cpp
// First we create the empty stream set
FRealtimeMeshStreamSet StreamSet;

// Then we can add whatever streams to it we want
FRealtimeMeshStream& PositionStream = StreamSet.AddStream<FVector3f>(FRealtimeMeshStreams::Position);
FRealtimeMeshStream& TangentsStream = StreamSet.AddStream<FRealtimeMeshTangentsNormalPrecision>(FRealtimeMeshStreams::Tangents);

// We can choose to add the streams to a link pool if we want to
StreamSet.AddStreamToLinkPool("Vertices", FRealtimeMeshStreams::Position, FRealtimeMeshStreamDefaultRowValue::Create(FVector3f::ZeroVector));
StreamSet.AddStreamToLinkPool("Vertices", FRealtimeMeshStreams::Tangents, FRealtimeMeshStreamDefaultRowValue::Create(
    FRealtimeMeshTangentsNormalPrecision(FVector3f::ZAxisVector, FVector3f::XAxisVector),
    TangentsStream.GetLayout()));

// Then we can bind the stream builds to the contained streams like a individual stream
TRealtimeMeshStreamBuilder<FVector3f> PositionStreamBuilder(StreamSet.FindChecked(FRealtimeMeshStreams::Position));
```

--------------------------------

### Create a basic mesh builder local

Source: https://rmc.triaxis.games/keyconcepts/mesh-local-builder/index.print

Initializes a mesh builder with a stream set and configures vertex elements before adding geometry.

```cpp
// First we create the empty stream set
FRealtimeMeshStreamSet StreamSet;

// Then we can bind the Mesh Builder Local to it.
// We can configure the stream data types through the template parameters
// We can also supply void to get dynamic conversion for unknown stream layouts.
TRealtimeMeshBuilderLocal<uint16, FPackedNormal, FVector2DHalf, 1> Builder(StreamSet);

// We can decide what vertex elements are enabled.
Builder.EnableTangents();
Builder.EnableTexCoords();
Builder.EnableColors();
Builder.EnablePolyGroups();

// We can add a vertex, and optionally set things like the tangents, color, texcoords.
// We can then get the new index from it to use later.
int32 V0 = Builder.AddVertex(FVector3f(-50.0f, 0.0f, 0.0f))
    .SetNormalAndTangent(FVector3f(0.0f, -1.0f, 1.0f), FVector3f(1.0f, 0.0f, 0.0f))
    .SetColor(FColor::Red)
    .SetTexCoord(FVector2f(0.0f, 0.0f));

// Now we can add a triangle giving it the indices of the vertices for the 3 corners, as well as optionally supplying the polygroup
Builder.AddTriangle(V0, V1, V2, 0);
```

--------------------------------

### Create and Bind Stream Linkage

Source: https://rmc.triaxis.games/keyconcepts/stream-linkage/index.print

Demonstrates initializing vertex streams, binding them to a linkage with default values, and using builders to manage synchronized stream sizes.

```cpp
// Create our position stream
auto PositionStream = FRealtimeMeshStream::Create<FVector3f>(FRealtimeMeshStreams::Position);

// Create our tangents stream
auto TangentsStream = FRealtimeMeshStream::Create<FRealtimeMeshTangentsNormalPrecision>(FRealtimeMeshStreams::Tangents);

// Create our linkage that we'll use to bind the vertex streams together
FRealtimeMeshStreamLinkage VerticesLinkage;

// Bind the position stream, with a deafult value of zero vector.
// We can do this simply because we know the type
VerticesLinkage.BindStream(PositionStream, FRealtimeMeshStreamDefaultRowValue::Create(FVector3f::ZeroVector));

// Bind the tangents stream, we create the default value by passing it our wanted value, and getting the final layout from the stream.
// This lets it do the conversion once and then just blit this value into the stream.
VerticesLinkage.BindStream(TangentsStream, FRealtimeMeshStreamDefaultRowValue::Create(
    FRealtimeMeshTangentsNormalPrecision(FVector3f::ZAxisVector, FVector3f::XAxisVector),
    TangentsStream.GetLayout()));

// We can setup the two builders to make working with the streams easier    
TRealtimeMeshStreamBuilder<FVector3f> PositionStreamBuilder(PositionStream);
TRealtimeMeshStreamBuilder<FRealtimeMeshTangentsHighPrecision, FRealtimeMeshTangentsNormalPrecision> TangentsStreamBuilder(TangentsStream);

// This will add the position to the position stream. It will also set the tangents stream size to the same size and default the value
// You should *NOT* use .Add on the secondary streams when setting the value, you can just used the indexed set. 
// It doesn't matter which stream you call .Add() on, it will resize them all.
int32 Index = PositionStreamBuilder.Add(FVector3f(1, 0, 0));

// Here we just set the tangent entry for this index
// If you call .Add() again then you'll end up with 2 vertices in both streams, instead of 1 vertex with the tangent set for the existing vertex
TangentsStreamBuilder[Index] = FRealtimeMeshTangentsHighPrecision(FVector3f(0, 1, 0), FVector3f(0, 0, 1));
```

--------------------------------

### Create a Strided Stream Builder

Source: https://rmc.triaxis.games/keyconcepts/stream-builder/index.print

Shows how to handle multi-channel data streams using strided builders for specific channel access.

```cpp
// This creates a texcoords stream with 4 channels using the packed type FVector2DHalf.
auto TexCoordsStream = FRealtimeMeshStream::Create<TRealtimeMeshTexCoords<FVector2DHalf, 4>>(FRealtimeMeshStreams::TexCoords);

// We can do the same stream builder setup as above to work with all 4 channels at the same time
TRealtimeMeshStreamBuilder<TRealtimeMeshTexCoords<FVector2DHalf, 4>> TexCoordStreamBuilder(TexCoordsStream);

// Here we use the strided builder to work with channel 1 as though it was an array of FVector2f and let the builder
// perform the conversion internally.  This can be done with with all the same variations as a normal builder for no-conversion, direct-conversion, or dynamic conversion.
TRealtimeMeshStridedStreamBuilder<FVector2f, FVector2DHalf> TexCoordStreamBuilder(TexCoordsStream, 1);
```

--------------------------------

### Create a Stream Accessor

Source: https://rmc.triaxis.games/keyconcepts/stream-builder/index.print

Demonstrates initializing stream builders with varying levels of type safety and conversion overhead.

```cpp
// For example, this will create a stream with the key `Vertex:Position` and the datatype of FVector3f
auto PositionStream = FRealtimeMeshStream::Create<FVector3f>(FRealtimeMeshStreams::Position);

// This will create a simple StreamBuilder where you know the type is FVector3f. This will assert if the types do not match
// This does allow for the fastest interaction with the stream as no internal conversion is performed.
TRealtimeMeshStreamBuilder<FVector3f> PositionStreamBuilder(PositionStream);

// This will create a simple StreamBuilder where you want to work with it as if the data was FVector3d, but the actual streamdata is FVector3f.
// This will incur a slight overhead as it will do the conversion both ways internally, 
// but this is all done through templates, so it's the least overhead of the conversion available
TRealtimeMeshStreamBuilder<FVector3d, FVector3f> PositionStreamBuilder(PositionStream);

// This will create a StreamBuilder where you want to treat the data as a FVector3d, but you don't know the format of the stream. 
// This will perform a dynamic conversion internally, but the formats must be compatible. 
// In this case FVector3d, or FVector3f are safe, as well as custom data types of the same setup
TRealtimeMeshStreamBuilder<FVector3d, void> PositionStreamBuilder(PositionStream);
```

--------------------------------

### Create a Stream

Source: https://rmc.triaxis.games/keyconcepts/streams/index.print.html

Initializes a new stream with a specific data type and key.

```cpp
// For example, this will create a stream with the key `Vertex:Position` and the datatype of FVector3f
auto PositionStream = FRealtimeMeshStream::Create<FVector3f>(FRealtimeMeshStreams::Position);
```

--------------------------------

### Stream Builder Operations: Reserve and Append

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Shows how to preallocate internal storage for a specified number of elements using 'Reserve' and append multiple elements from an initializer list using 'Append'.

```cpp
PositionStreamBuilder.Reserve(100);

PositionStreamBuilder.Append({ FVector3f(0, 0, 0), FVector3f(1, 1, 1), FVector3f(2, 2, 2) });
```

--------------------------------

### Copy a Stream Set

Source: https://rmc.triaxis.games/keyconcepts/stream-set/index.print

Illustrates how to explicitly copy a Stream Set using its copy constructor. Implicit copy and assignment are disallowed for performance reasons.

```cpp
// Use the explicit copy constructor as implicit copy and assignment are disallowed for performance reasons.
FRealtimeMeshStreamSet StreamSet2(StreamSet);
```

--------------------------------

### Create a Typed Stream Builder

Source: https://rmc.triaxis.games/index.print.html

Initialize a StreamBuilder for a specific data type to enable array-like operations. Direct conversion builders offer the fastest interaction.

```cpp
TRealtimeMeshStreamBuilder<FVector3f> PositionStreamBuilder(PositionStream);
```

```cpp
TRealtimeMeshStreamBuilder<FVector3d, FVector3f> PositionStreamBuilder(PositionStream);
```

```cpp
TRealtimeMeshStreamBuilder<FVector3d, void> PositionStreamBuilder(PositionStream);
```

--------------------------------

### Stream Builder Operations: Add and Emplace

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Demonstrates adding a new element to the stream using 'Add' with a value and 'Emplace' with an initializer list.

```cpp
PositionStreamBuilder.Add(FVector3f(0, 0, 0));

TexCoordsStreamBuilder.Emplace({ FVector2f(0, 0), FVector2f(0, 0) });
```

--------------------------------

### Stream Miscellaneous Helpers

Source: https://rmc.triaxis.games/keyconcepts/streams/index.print.html

Utility methods for filling, zeroing, and preallocating memory within a stream.

```cpp
// Fill the stream starting at position 10 and running for 20 elements with a default value
PositionStream.FillRange(10, 20, FVector3f(0, 0, 1));

// Zero a range of the stream starting at index 10 and running the next 20 elements
PositionStream.ZeroRange(10, 20);

// Preallocate the stream to hold 128 rows, this can cut down on reallocation and data copying.
PositionStream.Reserve(128);
```

--------------------------------

### Create a Stream

Source: https://rmc.triaxis.games/keyconcepts/streams/index.print

Creates a stream for a specific data type and stream key. Ensure the stream key is valid for the intended data.

```cpp
auto PositionStream = FRealtimeMeshStream::Create<FVector3f>(FRealtimeMeshStreams::Position);
```

--------------------------------

### Stream Miscellaneous Helpers

Source: https://rmc.triaxis.games/keyconcepts/streams/index.print

Provides utility functions for streams, including filling a range with a default value, zeroing a range, and preallocating memory to optimize performance.

```cpp
PositionStream.FillRange(10, 20, FVector3f(0, 0, 1));

PositionStream.ZeroRange(10, 20);

PositionStream.Reserve(128);
```

--------------------------------

### Working with Stream Builders

Source: https://rmc.triaxis.games/keyconcepts/stream-builder/index.print

Common operations for manipulating stream data using array-like methods.

```cpp
// Stream Builders let you treat a stream much like a TArray
// So you have all the normal functions, plus some specialized helpers.
// Some examples are: 

// Add a element
PositionStreamBuilder.Add(FVector3f(0, 0, 0));

// Emplace an element
TexCoordsStreamBuilder.Emplace({ FVector2f(0, 0), FVector2f(0, 0) });

// Reserve the number of elements, preallocating the internal storage
PositionStreamBuilder.Reserve(100);

// Append an initializer list of 3 elements
PositionStreamBuilder.Append({ FVector3f(0, 0, 0), FVector3f(1, 1, 1), FVector3f(2, 2, 2) });

// Remove element 1
PositionStreamBuilder.RemoveAt(1);

// Set the number of elements filling any new elements with the supplied value.
PositionStreamBuilder.SetNumWithFill(128, FVector3f(0, 0, 1));
```

--------------------------------

### Stream Builder Operations: RemoveAt and SetNumWithFill

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Illustrates removing an element at a specific index using 'RemoveAt' and resizing the stream to a new number of elements, filling any new elements with a specified value using 'SetNumWithFill'.

```cpp
PositionStreamBuilder.RemoveAt(1);

PositionStreamBuilder.SetNumWithFill(128, FVector3f(0, 0, 1));
```

--------------------------------

### Move a Stream Set

Source: https://rmc.triaxis.games/keyconcepts/stream-set/index.print

Shows how to move a Stream Set using move assignment. This is an efficient operation as it transfers ownership without duplicating data, resetting the source Stream Set.

```cpp
// Move assignment is fast because it does not duplicate the data and instead moves the ownership of it.
FRealtimeMeshStreamSet StreamSet2 = MoveTemp(StreamSet);
```

--------------------------------

### Add RMC to Build.cs

Source: https://rmc.triaxis.games/installation/installation-from-marketplace/index.print.html

Add this line to your project's Build.cs file to include the Realtime Mesh Component module when using C++.

```csharp
PublicDependencyModuleNames.Add("RealtimeMeshComponent");
```

--------------------------------

### Create a Strided Stream Builder

Source: https://rmc.triaxis.games/index.print.html

Use a Strided Stream Builder to work with specific channels of a multi-channel stream, like texcoords. Various conversion options are available.

```cpp
auto TexCoordsStream = FRealtimeMeshStream::Create<TRealtimeMeshTexCoords<FVector2DHalf, 4>>(FRealtimeMeshStreams::TexCoords);
```

```cpp
TRealtimeMeshStreamBuilder<TRealtimeMeshTexCoords<FVector2DHalf, 4>> TexCoordStreamBuilder(TexCoordsStream);
```

```cpp
TRealtimeMeshStridedStreamBuilder<FVector2f, FVector2DHalf> TexCoordStreamBuilder(TexCoordsStream, 1);
```

--------------------------------

### Create Stream Accessor with Dynamic Conversion

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Creates a stream accessor and initializes a StreamBuilder to treat data as a specific type (FVector3d) without knowing the stream's concrete format. This performs dynamic conversion for compatible formats.

```cpp
TRealtimeMeshStreamBuilder<FVector3d, void> PositionStreamBuilder(PositionStream);
```

--------------------------------

### Create Strided Stream Builder for Multi-Channel Data

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Initializes a StreamBuilder for a multi-channel texcoords stream using a packed type (FVector2DHalf). This builder can work with all channels simultaneously.

```cpp
auto TexCoordsStream = FRealtimeMeshStream::Create<TRealtimeMeshTexCoords<FVector2DHalf, 4>>(FRealtimeMeshStreams::TexCoords);

TRealtimeMeshStreamBuilder<TRealtimeMeshTexCoords<FVector2DHalf, 4>> TexCoordStreamBuilder(TexCoordsStream);
```

--------------------------------

### Create Stream Accessor with Type Conversion

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Creates a stream accessor and initializes a StreamBuilder to work with a different data type (FVector3d) than the stream's actual data (FVector3f), incurring a small template-based conversion overhead.

```cpp
TRealtimeMeshStreamBuilder<FVector3d, FVector3f> PositionStreamBuilder(PositionStream);
```

--------------------------------

### Bulk Add Data to a Stream

Source: https://rmc.triaxis.games/index.print.html

Append an entire TArray of data to an existing stream efficiently. Ensure the stream is already created and the data type matches.

```cpp
TArray<FVector3f> IncomingData;

// ... fill IncomingData ...

PositionStream.Append(IncomingData);
```

--------------------------------

### FRealtimeMeshComponentProxy

Source: https://rmc.triaxis.games/component-core/structure

Represents the render thread counterpart to URealtimeMeshComponent, managing the render thread state.

```APIDOC
## FRealtimeMeshComponentProxy

### Description
The render thread counterpart to URealtimeMeshComponent. It owns the render thread state of a URealtimeMeshComponent, including its linkage to the underlying FRealtimeMeshProxy to facilitate the component rendering.
```

--------------------------------

### FRealtimeMeshComponentProxy

Source: https://rmc.triaxis.games/component-core/index.print

Represents the render thread counterpart to URealtimeMeshComponent, managing component rendering state.

```APIDOC
## FRealtimeMeshComponentProxy

### Description
The render thread counterpart to URealtimeMeshComponent. It owns the render thread state of a URealtimeMeshComponent, including its linkage to the underlying FRealtimeMeshProxy to facilitate component rendering.
```

--------------------------------

### Bulk Add Data to Stream

Source: https://rmc.triaxis.games/keyconcepts/streams/index.print.html

Appends an entire array of data to an existing stream.

```cpp
// If you have an array like the following (assuming it's filled with data)
TArray<FVector3f> IncomingData;

// You could add all of this at once through
PositionStream.Append(IncomingData);
```

--------------------------------

### Create Stream Accessor with Known Type

Source: https://rmc.triaxis.games/keyconcepts/stream-builder

Creates a stream accessor for a known data type (FVector3f) and initializes a StreamBuilder without internal conversion for maximum performance.

```cpp
auto PositionStream = FRealtimeMeshStream::Create<FVector3f>(FRealtimeMeshStreams::Position);

TRealtimeMeshStreamBuilder<FVector3f> PositionStreamBuilder(PositionStream);
```

--------------------------------

### Stream Builder Operations

Source: https://rmc.triaxis.games/index.print.html

Perform common array-like operations using Stream Builders, including adding, emplacing, reserving, appending, removing, and setting element counts.

```cpp
// Add a element
PositionStreamBuilder.Add(FVector3f(0, 0, 0));
```

```cpp
// Emplace an element
TexCoordsStreamBuilder.Emplace({ FVector2f(0, 0), FVector2f(0, 0) });
```

```cpp
// Reserve the number of elements, preallocating the internal storage
PositionStreamBuilder.Reserve(100);
```

```cpp
// Append an initializer list of 3 elements
PositionStreamBuilder.Append({ FVector3f(0, 0, 0), FVector3f(1, 1, 1), FVector3f(2, 2, 2) });
```

```cpp
// Remove element 1
PositionStreamBuilder.RemoveAt(1);
```

```cpp
// Set the number of elements filling any new elements with the supplied value.
PositionStreamBuilder.SetNumWithFill(128, FVector3f(0, 0, 1));
```
Tokens:
Raw