### Initialize Realtime Mesh Component in C++

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Demonstrates the setup process for a RealtimeMeshComponent within an Unreal Engine actor. It covers creating the component and initializing it with a simple mesh type.

```cpp
#include "RealtimeMeshComponent.h"
#include "RealtimeMeshSimple.h"

void AMyActor::SetupMesh()
{
    // Create the component
    URealtimeMeshComponent* MeshComponent = CreateDefaultSubobject<URealtimeMeshComponent>(TEXT("RealtimeMesh"));

    // Initialize with the simple mesh type (most common use case)
    URealtimeMeshSimple* RealtimeMesh = MeshComponent->InitializeRealtimeMesh<URealtimeMeshSimple>();

    // Alternative: Initialize from Blueprint
    // RealtimeMesh = MeshComponent->InitializeRealtimeMesh(URealtimeMeshSimple::StaticClass());

    if (RealtimeMesh)
    {
        UE_LOG(LogTemp, Log, TEXT("Realtime Mesh initialized successfully"));
    }
}
```

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

### Implement Mesh Generation Events in C++

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Demonstrates how to extend URealtimeMeshSimple to implement procedural mesh generation using a mesh builder. It covers vertex initialization, tangent/texture coordinate setup, and triangle indexing.

```cpp
UCLASS()
class UMyProceduralMesh : public URealtimeMeshSimple
{
    GENERATED_BODY()

public:
    virtual void OnGenerateMesh_Implementation(URealtimeMesh* TargetMesh) override
    {
        URealtimeMeshSimple* SimpleMesh = Cast<URealtimeMeshSimple>(TargetMesh);
        if (!SimpleMesh) return;

        FRealtimeMeshStreamSet StreamSet;
        TRealtimeMeshBuilderLocal<uint16, FPackedNormal, FVector2DHalf, 1> Builder(StreamSet);

        Builder.EnableTangents();
        Builder.EnableTexCoords();

        for (int32 Y = 0; Y < 10; Y++)
        {
            for (int32 X = 0; X < 10; X++)
            {
                float Height = FMath::PerlinNoise2D(FVector2D(X * 0.1f, Y * 0.1f)) * 100.0f;
                Builder.AddVertex(FVector3f(X * 100.0f, Y * 100.0f, Height))
                    .SetNormalAndTangent(FVector3f(0, 0, 1), FVector3f(1, 0, 0))
                    .SetTexCoord(FVector2f(X / 10.0f, Y / 10.0f));
            }
        }

        for (int32 Y = 0; Y < 9; Y++)
        {
            for (int32 X = 0; X < 9; X++)
            {
                int32 V0 = Y * 10 + X;
                int32 V1 = V0 + 1;
                int32 V2 = V0 + 10;
                int32 V3 = V2 + 1;

                Builder.AddTriangle(V0, V2, V1);
                Builder.AddTriangle(V1, V2, V3);
            }
        }

        FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("Terrain"));
        SimpleMesh->CreateSectionGroup(GroupKey, StreamSet);
    }
};
```

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

### Create Basic Triangle Mesh with Stream Builder in C++

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Illustrates how to procedurally generate a triangle mesh using the Realtime Mesh Stream Builder. This includes configuring vertices, normals, UVs, and colors before committing the geometry to a section group.

```cpp
#include "RealtimeMeshSimple.h"
#include "Core/RealtimeMeshBuilder.h"

using namespace RealtimeMesh;

void CreateTriangle(URealtimeMeshSimple* RealtimeMesh)
{
    // Create the stream set - contains all mesh data buffers
    FRealtimeMeshStreamSet StreamSet;

    // Initialize builder with 16-bit indices, packed normals, half-precision UVs
    TRealtimeMeshBuilderLocal<uint16, FPackedNormal, FVector2DHalf, 1> Builder(StreamSet);

    // Enable mesh features
    Builder.EnableTangents();
    Builder.EnableTexCoords();
    Builder.EnableColors();
    Builder.EnablePolyGroups();

    // Add vertices with chaining API
    int32 V0 = Builder.AddVertex(FVector3f(-50.0f, 0.0f, 0.0f))
        .SetNormalAndTangent(FVector3f(0.0f, -1.0f, 0.0f), FVector3f(1.0f, 0.0f, 0.0f))
        .SetColor(FColor::Red)
        .SetTexCoord(FVector2f(0.0f, 0.0f));

    int32 V1 = Builder.AddVertex(FVector3f(0.0f, 0.0f, 100.0f))
        .SetNormalAndTangent(FVector3f(0.0f, -1.0f, 0.0f), FVector3f(1.0f, 0.0f, 0.0f))
        .SetColor(FColor::Green)
        .SetTexCoord(FVector2f(0.5f, 1.0f));

    int32 V2 = Builder.AddVertex(FVector3f(50.0, 0.0, 0.0))
        .SetNormalAndTangent(FVector3f(0.0f, -1.0f, 0.0f), FVector3f(1.0f, 0.0f, 0.0f))
        .SetColor(FColor::Blue)
        .SetTexCoord(FVector2f(1.0f, 0.0f));

    // Add triangle with counter-clockwise winding and polygroup index
    Builder.AddTriangle(V0, V1, V2, 0);

    // Setup material slots
    RealtimeMesh->SetupMaterialSlot(0, "PrimaryMaterial");

    // Create section group key (unique identifier for shared buffers)
    const FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("TestTriangle"));

    // Create the section group with the stream set
    RealtimeMesh->CreateSectionGroup(GroupKey, StreamSet);

    // Configure section with material slot
    const FRealtimeMeshSectionKey SectionKey = FRealtimeMeshSectionKey::CreateForPolyGroup(GroupKey, 0);
    RealtimeMesh->UpdateSectionConfig(SectionKey, FRealtimeMeshSectionConfig(0));
}
```

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

### Configure Simple Collision with RealtimeMeshComponent

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Explains how to set up basic collision shapes for physics interactions, including spheres, boxes, capsules, and convex hulls. It covers configuring collision settings, adding, updating, and removing shapes using `RealtimeMeshCollisionLibrary` and `RealtimeMeshSimpleGeometryFunctionLibrary`.

```cpp
#include "RealtimeMeshCollisionLibrary.h"

void SetupSimpleCollision(URealtimeMeshSimple* RealtimeMesh)
{
    // Get current collision configuration
    FRealtimeMeshCollisionConfiguration CollisionConfig = RealtimeMesh->GetCollisionConfig();
    CollisionConfig.bUseComplexAsSimpleCollision = false;
    CollisionConfig.bUseAsyncCook = true;
    RealtimeMesh->SetCollisionConfig(CollisionConfig);

    // Create simple geometry
    FRealtimeMeshSimpleGeometry SimpleGeometry;

    // Add sphere collision
    FRealtimeMeshCollisionSphere Sphere;
    Sphere.Name = FName("CenterSphere");
    Sphere.Center = FVector(0, 0, 50);
    Sphere.Radius = 50.0f;
    int32 SphereIndex;
    URealtimeMeshSimpleGeometryFunctionLibrary::AddSphere(SimpleGeometry, Sphere, SphereIndex);

    // Add box collision
    FRealtimeMeshCollisionBox Box;
    Box.Name = FName("BaseBox");
    Box.Transform = FTransform(FVector(0, 0, 0));
    Box.Extents = FVector(100, 100, 50);
    int32 BoxIndex;
    URealtimeMeshSimpleGeometryFunctionLibrary::AddBox(SimpleGeometry, Box, BoxIndex);

    // Add capsule collision
    FRealtimeMeshCollisionCapsule Capsule;
    Capsule.Name = FName("BodyCapsule");
    Capsule.Center = FVector(0, 0, 100);
    Capsule.Radius = 40.0f;
    Capsule.HalfLength = 80.0f;
    Capsule.Rotation = FRotator(0, 0, 0);
    int32 CapsuleIndex;
    URealtimeMeshSimpleGeometryFunctionLibrary::AddCapsule(SimpleGeometry, Capsule, CapsuleIndex);

    // Add convex hull collision
    FRealtimeMeshCollisionConvex ConvexHull;
    ConvexHull.Name = FName("CustomShape");
    ConvexHull.Vertices = {
        FVector(0, 0, 0), FVector(100, 0, 0), FVector(100, 100, 0),
        FVector(0, 100, 0), FVector(50, 50, 100)
    };
    URealtimeMeshCollisionTools::CookConvexHull(ConvexHull);
    int32 ConvexIndex;
    URealtimeMeshSimpleGeometryFunctionLibrary::AddConvex(SimpleGeometry, ConvexHull, ConvexIndex);

    // Apply simple geometry to mesh
    RealtimeMesh->SetSimpleGeometry(SimpleGeometry);

    // Update existing shapes
    bool bSuccess;
    Sphere.Radius = 60.0f;
    URealtimeMeshSimpleGeometryFunctionLibrary::UpdateSphere(SimpleGeometry, SphereIndex, Sphere, bSuccess);

    // Remove shapes
    URealtimeMeshSimpleGeometryFunctionLibrary::RemoveBoxByName(SimpleGeometry, FName("BaseBox"), bSuccess);
}
```

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

### Configure Material Slots in RealtimeMeshComponent

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Demonstrates how to load materials, assign them to indexed slots on a RealtimeMesh component, and query slot metadata such as names and validity. This is essential for procedural mesh rendering where multiple materials are required for different geometry sections.

```cpp
void ConfigureMaterials(URealtimeMesh* RealtimeMesh)
{
	// Load materials
	UMaterialInterface* BaseMaterial = LoadObject<UMaterialInterface>(nullptr,
		TEXT("/Game/Materials/M_Base.M_Base"));
	UMaterialInterface* DetailMaterial = LoadObject<UMaterialInterface>(nullptr,
		TEXT("/Game/Materials/M_Detail.M_Detail"));

	// Setup material slots
	RealtimeMesh->SetupMaterialSlot(0, FName("Base"), BaseMaterial);
	RealtimeMesh->SetupMaterialSlot(1, FName("Detail"), DetailMaterial);
	RealtimeMesh->SetupMaterialSlot(2, FName("Trim"), nullptr);  // Will use override from component

	// Query material information
	int32 MaterialCount = RealtimeMesh->GetNumMaterials();
	FName SlotName = RealtimeMesh->GetMaterialSlotName(0);
	int32 SlotIndex = RealtimeMesh->GetMaterialIndex(FName("Detail"));
	bool bIsValid = RealtimeMesh->IsMaterialSlotNameValid(FName("Base"));

	// Get all slot names
	TArray<FName> SlotNames = RealtimeMesh->GetMaterialSlotNames();
	for (const FName& Name : SlotNames)
	{
		UE_LOG(LogTemp, Log, TEXT("Material Slot: %s"), *Name.ToString());
	}

	// Get material at slot
	UMaterialInterface* Material = RealtimeMesh->GetMaterial(0);
}
```

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

### Manage Mesh Bounds and Data Lifecycle

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Utilities for resetting mesh state, retrieving bounding information, and toggling persistence settings like serialization and network support.

```cpp
void ManageMesh(URealtimeMesh* RealtimeMesh)
{
    FBoxSphereBounds LocalBounds = RealtimeMesh->GetLocalBounds();
    UE_LOG(LogTemp, Log, TEXT("Mesh Bounds: Origin=%s, Extent=%s"),
        *LocalBounds.Origin.ToString(),
        *LocalBounds.BoxExtent.ToString());

    RealtimeMesh->Reset();

    RealtimeMesh->SetShouldSerializeMeshData(true);
    bool bWillSerialize = RealtimeMesh->ShouldSerializeMeshData();

    bool bNetworked = RealtimeMesh->IsSupportedForNetworking();
}
```

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

### Manage Mesh Sections and Section Groups

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Covers the creation and configuration of mesh sections using FRealtimeMeshSectionKey and FRealtimeMeshSectionGroupKey. Shows how to define stream ranges, manage visibility, control shadow casting, and remove sections from the mesh component.

```cpp
void ManageSections(URealtimeMeshSimple* RealtimeMesh)
{
	// Create section group key (LOD 0, named "Terrain")
	FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("Terrain"));

	// Create section keys within the group
	FRealtimeMeshSectionKey Section0 = FRealtimeMeshSectionKey::Create(GroupKey, 0);
	FRealtimeMeshSectionKey Section1 = FRealtimeMeshSectionKey::Create(GroupKey, 1);

	// Or create based on polygroup index
	FRealtimeMeshSectionKey PolyGroupSection = FRealtimeMeshSectionKey::CreateForPolyGroup(GroupKey, 0);

	// Create section with configuration
	FRealtimeMeshSectionConfig SectionConfig;
	SectionConfig.MaterialSlot = 0;
	SectionConfig.bIsVisible = true;
	SectionConfig.bCastsShadow = true;

	FRealtimeMeshStreamRange StreamRange;
	StreamRange.Vertices = FInt32Range(0, 100);  // Use vertices 0-99
	StreamRange.Indices = FInt32Range(0, 300);   // Use indices 0-299

	RealtimeMesh->CreateSection(Section0, SectionConfig, StreamRange, true);

	// Update section configuration
	SectionConfig.MaterialSlot = 1;
	RealtimeMesh->UpdateSectionConfig(Section0, SectionConfig, false);

	// Update section visibility
	RealtimeMesh->SetSectionVisibility(Section0, false);

	// Update section shadow casting
	RealtimeMesh->SetSectionCastShadow(Section0, false);

	// Query section state
	FRealtimeMeshSectionConfig Config = RealtimeMesh->GetSectionConfig(Section0);
	bool bIsVisible = RealtimeMesh->IsSectionVisible(Section0);
	bool bCastsShadow = RealtimeMesh->IsSectionCastingShadow(Section0);

	// Get all sections in a group
	TArray<FRealtimeMeshSectionKey> Sections = RealtimeMesh->GetSectionsInGroup(GroupKey);

	// Remove sections
	RealtimeMesh->RemoveSection(Section0);
	RealtimeMesh->RemoveSectionGroup(GroupKey);
}
```

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

### Configure Levels of Detail (LOD)

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Demonstrates how to add, manage, and update Levels of Detail for a mesh. This is critical for controlling rendering performance by adjusting screen-space thresholds for different mesh complexities.

```cpp
#include "RealtimeMesh.h"

void SetupLODs(URealtimeMesh* RealtimeMesh)
{
	FRealtimeMeshLODConfig LOD0Config;
	LOD0Config.bIsVisible = true;
	LOD0Config.ScreenSize = 1.0f;
	FRealtimeMeshLODKey LOD0 = RealtimeMesh->AddLOD(LOD0Config);

	FRealtimeMeshLODConfig LOD1Config;
	LOD1Config.bIsVisible = true;
	LOD1Config.ScreenSize = 0.5f;
	FRealtimeMeshLODKey LOD1 = RealtimeMesh->AddLOD(LOD1Config);

	FRealtimeMeshLODConfig LOD2Config;
	LOD2Config.bIsVisible = true;
	LOD2Config.ScreenSize = 0.25f;
	FRealtimeMeshLODKey LOD2 = RealtimeMesh->AddLOD(LOD2Config);

	LOD1Config.ScreenSize = 0.6f;
	RealtimeMesh->UpdateLODConfig(LOD1, LOD1Config);

	RealtimeMesh->RemoveTrailingLOD();
}
```

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

### Create and Modify Meshes with Blueprint Mesh Builder

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Utilizes the URealtimeMeshLocalBuilder to construct procedural meshes. It covers stream set initialization, vertex and triangle addition, and the fluent API for configuring mesh attributes like tangents and colors.

```cpp
#include "Mesh/RealtimeMeshBlueprintMeshBuilder.h"

void BlueprintStyleMeshCreation(URealtimeMeshSimple* RealtimeMesh)
{
	URealtimeMeshStreamSet* StreamSet = NewObject<URealtimeMeshStreamSet>();

	URealtimeMeshLocalBuilder* Builder = StreamSet->MakeLocalMeshBuilder(
		ERealtimeMeshSimpleStreamConfig::Normal,
		ERealtimeMeshSimpleStreamConfig::Normal,
		false,
		ERealtimeMeshSimpleStreamConfig::None,
		true,
		1,
		false
	);

	Builder->EnableTangents(false)
	       ->EnableColors()
	       ->EnableTexCoords(2);

	FRealtimeMeshBasicVertex Vertex;
	Vertex.Position = FVector(-50.0f, 0.0f, 0.0f);
	Vertex.Normal = FVector(0.0f, 0.0f, 1.0f);
	Vertex.Tangent = FVector(1.0f, 0.0f, 0.0f);
	Vertex.Color = FLinearColor::Red;
	Vertex.UV0 = FVector2D(0.0f, 0.0f);

	URealtimeMeshLocalBuilder* BuilderRef = Builder;
	int32 V0 = Builder->AddVertex(BuilderRef, Vertex);

	Builder->EditVertex(BuilderRef, V0,
		FVector(-100.0f, 0.0f, 0.0f), true,
		FVector(0.0f, 0.0f, 1.0f), false,
		FVector(1.0f, 0.0f, 0.0f), false,
		FLinearColor::Blue, true,
		FVector2D(0.0f, 0.0f), false,
		FVector2D::Zero(), false,
		FVector2D::Zero(), false,
		FVector2D::Zero(), false
	);

	Builder->AddTriangle(BuilderRef, 0, 1, 2, 0);

	FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("BlueprintMesh"));

	FRealtimeMeshSimpleCompletionCallback Callback;
	RealtimeMesh->CreateSectionGroup(GroupKey, StreamSet, Callback);
}
```

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

### Edit Mesh Data In-Place with RealtimeMeshComponent

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Demonstrates how to modify existing mesh data directly without needing to recreate the entire mesh. This involves accessing mesh streams and applying changes, with a focus on vertex positions. It utilizes `EditMeshInPlace` for direct manipulation and `ProcessMesh` for read-only access.

```cpp
void EditMeshData(URealtimeMeshSimple* RealtimeMesh)
{
    FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("Terrain"));

    // Read-only access to mesh data
    RealtimeMesh->ProcessMesh(GroupKey, [](const RealtimeMesh::FRealtimeMeshStreamSet& StreamSet)
    {
        // Read vertex positions
        if (const RealtimeMesh::FRealtimeMeshStream* PositionStream = StreamSet.Find(FRealtimeMeshStreams::Position))
        {
            TRealtimeMeshStreamBuilder<FVector3f> Positions(*PositionStream);
            for (int32 i = 0; i < Positions.Num(); i++)
            {
                FVector3f Position = Positions[i];
                UE_LOG(LogTemp, Log, TEXT("Vertex %d: %s"), i, *Position.ToString());
            }
        }
    });

    // Edit mesh data in place
    TFuture<ERealtimeMeshProxyUpdateStatus> Result = RealtimeMesh->EditMeshInPlace(GroupKey,
        [](RealtimeMesh::FRealtimeMeshStreamSet& StreamSet) -> TSet<FRealtimeMeshStreamKey>
    {
        TSet<FRealtimeMeshStreamKey> UpdatedStreams;

        // Modify vertex positions
        if (RealtimeMesh::FRealtimeMeshStream* PositionStream = StreamSet.Find(FRealtimeMeshStreams::Position))
        {
            TRealtimeMeshStreamBuilder<FVector3f> Positions(*PositionStream);
            for (int32 i = 0; i < Positions.Num(); i++)
            {
                FVector3f& Position = Positions[i];
                Position.Z += FMath::Sin(i * 0.1f) * 10.0f;  // Wave effect
            }
            UpdatedStreams.Add(FRealtimeMeshStreams::Position);
        }

        return UpdatedStreams;
    });

    // Wait for update to complete
    ERealtimeMeshProxyUpdateStatus Status = Result.Get();
}
```

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

### Optimize Mesh Data with Stream Pool (C++)

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Implements object pooling for mesh data streams to minimize allocation overhead during frequent creation and destruction of mesh data. This involves requesting streams, stream sets, and builders from a pool, using them, and then returning them to the pool for reuse. Dependencies include Unreal Engine's Realtime Mesh Component.

```cpp
void UseStreamPool(URealtimeMeshComponent* MeshComponent)
{
    // Create a stream pool (typically store as member variable)
    URealtimeMeshStreamPool* StreamPool = NewObject<URealtimeMeshStreamPool>();

    // Request stream from pool
    FRealtimeMeshStreamKey StreamKey = FRealtimeMeshStreams::Position;
    URealtimeMeshStream* Stream = StreamPool->RequestStream(
        StreamKey,
        ERealtimeMeshSimpleStreamType::Vector3,
        3  // 3 elements per entry (x, y, z)
    );

    // Request stream set from pool
    URealtimeMeshStreamSet* StreamSet = StreamPool->RequestStreamSet();

    // Request mesh builder from pool
    URealtimeMeshLocalBuilder* Builder = StreamPool->RequestMeshBuilder();
    Builder->Initialize(
        ERealtimeMeshSimpleStreamConfig::Normal,  // Tangents
        ERealtimeMeshSimpleConfig::Normal,  // TexCoords
        false,                                    // 16-bit indices
        ERealtimeMeshSimpleStreamConfig::None,    // No polygroups
        true,                                     // Colors
        1,                                        // UV channels
        false                                     // Fresh start
    );

    // Use the builder to create mesh...
    URealtimeMeshLocalBuilder* BuilderRef = Builder;
    FRealtimeMeshBasicVertex Vertex;
    Vertex.Position = FVector(0, 0, 0);
    Builder->AddVertex(BuilderRef, Vertex);

    // Return to pool when done (reuse later)
    StreamPool->ReturnStream(Stream);
    StreamPool->ReturnStreamSet(StreamSet);
    StreamPool->ReturnMeshBuilder(Builder);

    // Return all at once
    StreamPool->ReturnAllStreams();

    // Free all (allow garbage collection)
    StreamPool->FreeAllStreams();
}

```

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

### Configure Complex Collision with Realtime Mesh (C++)

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Sets up complex mesh-based collision for accurate physics interactions. This involves enabling complex collision in the configuration, and then either auto-generating collision from mesh sections or providing custom complex mesh geometry. Dependencies include Unreal Engine's Realtime Mesh Component and collision tools.

```cpp
void SetupComplexCollision(URealtimeMeshSimple* RealtimeMesh)
{
    // Enable complex collision in configuration
    FRealtimeMeshCollisionConfiguration CollisionConfig = RealtimeMesh->GetCollisionConfig();
    CollisionConfig.bUseComplexAsSimpleCollision = true;
    CollisionConfig.bUseAsyncCook = true;
    RealtimeMesh->SetCollisionConfig(CollisionConfig);

    // Option 1: Auto-generate from mesh sections
    // By default, sections with collision enabled will be used
    FRealtimeMeshSectionGroupKey GroupKey = FRealtimeMeshSectionGroupKey::Create(0, FName("Terrain"));
    FRealtimeMeshSectionKey SectionKey = FRealtimeMeshSectionKey::Create(GroupKey, 0);

    FRealtimeMeshSectionConfig SectionConfig;
    SectionConfig.MaterialSlot = 0;

    FRealtimeMeshStreamRange StreamRange;
    StreamRange.Vertices = FInt32Range(0, 1000);
    StreamRange.Indices = FInt32Range(0, 3000);

    // true = create collision from this section
    RealtimeMesh->CreateSection(SectionKey, SectionConfig, StreamRange, true);

    // Option 2: Custom complex mesh geometry
    FRealtimeMeshComplexGeometry ComplexGeometry;
    FRealtimeMeshCollisionMesh CollisionMesh;

    // Build collision mesh from stream set
    FRealtimeMeshStreamSet StreamSet;
    TRealtimeMeshBuilderLocal<uint16, FPackedNormal, FVector2DHalf, 1> Builder(StreamSet);

    // Add collision geometry
    Builder.AddVertex(FVector3f(0, 0, 0));
    Builder.AddVertex(FVector3f(100, 0, 0));
    Builder.AddVertex(FVector3f(0, 100, 0));
    Builder.AddTriangle(0, 1, 2, 0);

    // Append to collision mesh
    int32 MaterialIndex = 0;
    URealtimeMeshCollisionTools::AppendStreamsToCollisionMesh(CollisionMesh, StreamSet, MaterialIndex);

    // Cook the collision mesh
    URealtimeMeshCollisionTools::CookComplexMesh(CollisionMesh);

    // Add to complex geometry
    ComplexGeometry.AddMesh(MoveTemp(CollisionMesh));

    // Set custom complex geometry
    RealtimeMesh->SetCustomComplexMeshGeometry(MoveTemp(ComplexGeometry));

    // Edit complex geometry in place
    RealtimeMesh->EditCustomComplexMeshGeometry([](FRealtimeMeshComplexGeometry& Geometry)
    {
        // Modify collision meshes
    });

    // Clear custom complex geometry
    RealtimeMesh->ClearCustomComplexMeshGeometry();
}

```

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

### Query UV Coordinates at Hit Location

Source: https://context7.com/triaxis-games/realtimemeshcomponent/llms.txt

Retrieves UV texture coordinates from a physical hit result, enabling features like decal placement or texture sampling at runtime. Supports both standard mesh queries and specialized collision UV tools.

```cpp
void HandleMeshHit(const FHitResult& Hit)
{
    URealtimeMeshComponent* HitComponent = Cast<URealtimeMeshComponent>(Hit.Component.Get());
    if (!HitComponent) return;

    URealtimeMesh* RealtimeMesh = HitComponent->GetRealtimeMesh();
    if (!RealtimeMesh) return;

    FVector2D UV;
    int32 UVChannel = 0;
    bool bSuccess = RealtimeMesh->CalcTexCoordAtLocation(
        Hit.ImpactPoint,
        Hit.Item,
        Hit.FaceIndex,
        UVChannel,
        UV
    );

    if (bSuccess)
    {
        UE_LOG(LogTemp, Log, TEXT("Hit UV: %s"), *UV.ToString());
    }

    FVector2D CollisionUV;
    bool bFoundUV = URealtimeMeshCollisionTools::FindCollisionUVRealtimeMesh(Hit, UVChannel, CollisionUV);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.