Multiple Materials in Nanite Mesh

[azpublic]

Hi Victor!

I was wondering if it was possible to have multiple materials in your runtime nanite mesh ?
The procedural mesh I am converting from does have multiple materials but when I convert it using the VoxelNaniteBuiilder they seem lost .. I tried fiddling by adding

// Optional - One material index per triangle
TConstVoxelArrayView MaterialIndices;

to the FMesh struct and modifying your pipeline a bit to handle the materials but to no success so far ...

Maybe I'm just doing something wrong or not seeing something obvious in your default pipeline .. .

Thanks for any help !

[Phyronnaz]

Hi there!

VoxelNaniteBuilder currently doesn't support material indices IIRC - this is something you'd need to add.
If you want to do so I'd recommend looking at the original Nanite code to see how they encode material indices.
There's quite a bit of code there that we don't replicate.

[azpublic]

Okay I'll check it out and report back ! Thanks

[azpublic]

Success !

After a lot of trial and error and a little help from Gemini I finally managed to have multiple materials in the generated static mesh.
It basically came down to properly split clusters by material and properly encode them in CreatePageData

Something like this :

`
void CreatePageData(
const TVoxelArrayView<TUniquePtr> Clusters,
const FEncodingSettings& EncodingSettings,
TVoxelChunkedArray& PageData)
{
VOXEL_FUNCTION_COUNTER();

const int32 PageStartIndex = PageData.Num();
const auto GetPageOffset = [&]
{
	return PageData.Num() - PageStartIndex;
};

const int32 NumUVs = Clusters[0]->TextureCoordinates.Num();

for (TUniquePtr<FCluster>& Cluster : Clusters)
{
	check(Cluster->NumTriangles() <= NANITE_MAX_CLUSTER_TRIANGLES);
	check(Cluster->TextureCoordinates.Num() == NumUVs);
}

TVoxelArray<FEncodingInfo> EncodingInfos;
EncodingInfos.Reserve(Clusters.Num());
for (TUniquePtr<FCluster>& Cluster : Clusters)
{
	EncodingInfos.Add(Cluster->GetEncodingInfo(EncodingSettings));
}

FPageSections PageGpuSizes;
for (const FEncodingInfo& EncodingInfo : EncodingInfos)
{
	PageGpuSizes += EncodingInfo.GpuSizes;
}

FPageSections GpuSectionOffsets = PageGpuSizes.GetOffsets();

TVoxelArray<FPackedCluster> PackedClusters;
PackedClusters.Reserve(Clusters.Num());
for (int32 ClusterIndex = 0; ClusterIndex < Clusters.Num(); ClusterIndex++)
{
	const FCluster& Cluster = *Clusters[ClusterIndex];
	const FEncodingInfo& Info = EncodingInfos[ClusterIndex];

	FPackedCluster& PackedCluster = PackedClusters.Emplace_GetRef();
	PackedCluster = Cluster.Pack(Info);



	// Set the offsets.  
	checkVoxelSlow(GpuSectionOffsets.Index % 4 == 0);
	checkVoxelSlow(GpuSectionOffsets.Position % 4 == 0);
	checkVoxelSlow(GpuSectionOffsets.Attribute % 4 == 0);
	PackedCluster.SetIndexOffset(GpuSectionOffsets.Index);
	PackedCluster.SetPositionOffset(GpuSectionOffsets.Position);
	PackedCluster.SetAttributeOffset(GpuSectionOffsets.Attribute);
	PackedCluster.SetDecodeInfoOffset(GpuSectionOffsets.DecodeInfo);



	{
		constexpr int32 NumBatchCountBits = 4;
		constexpr int32 NumTriCountBits = 5;

		TArray<uint32> BatchInfo;
		// Allocate enough space. 4 is the max for the fast path.
		BatchInfo.AddZeroed(4);

		uint32* DwordPtr = BatchInfo.GetData();
		uint32 BitOffset = 0;

		// Helper lambda.  
		auto AppendBits = [&](uint32 Bits, uint32 NumBits)
		{
			if (NumBits == 0) return;

			uint32 DwordIndex = BitOffset / 32;
			uint32 DwordBitOffset = BitOffset % 32;
			
			check(DwordIndex < (uint32)BatchInfo.Num());
			DwordPtr[DwordIndex] |= (Bits << DwordBitOffset);

			// Handle bits spilling over into the next dword
			if (DwordBitOffset + NumBits > 32)
			{
				check(DwordIndex + 1 < (uint32)BatchInfo.Num());
				DwordPtr[DwordIndex + 1] |= (Bits >> (32 - DwordBitOffset));
			}
			BitOffset += NumBits;
		};

		// --- Engine-Accurate Batch Calculation ---
		TArray<uint8> BatchTriCounts;
		if (Cluster.NumTriangles() > 0)
		{
			TStaticBitArray<NANITE_MAX_CLUSTER_VERTICES> UsedVertMask;
			uint32 NumUniqueVertsInBatch = 0;
			uint32 NumTrisInBatch = 0;
			const uint32 MaxBatchVerts = 32;
			const uint32 MaxBatchTris = 32;

			for (int32 TriIndex = 0; TriIndex < Cluster.NumTriangles(); ++TriIndex)
			{
				const uint32 VertIndex0 = Cluster.Indices[TriIndex * 3 + 0];
				const uint32 VertIndex1 = Cluster.Indices[TriIndex * 3 + 1];
				const uint32 VertIndex2 = Cluster.Indices[TriIndex * 3 + 2];
				
				const uint32 NumNewUniqueVerts = !UsedVertMask[VertIndex0] + !UsedVertMask[VertIndex1] + !UsedVertMask[VertIndex2];

				if ((NumUniqueVertsInBatch + NumNewUniqueVerts > MaxBatchVerts) || (NumTrisInBatch + 1 > MaxBatchTris))
				{
					check(NumTrisInBatch > 0);
					BatchTriCounts.Add(NumTrisInBatch);

					UsedVertMask = TStaticBitArray<NANITE_MAX_CLUSTER_VERTICES>();
					NumUniqueVertsInBatch = 0;
					NumTrisInBatch = 0;
				}

				UsedVertMask[VertIndex0] = true;
				UsedVertMask[VertIndex1] = true;
				UsedVertMask[VertIndex2] = true;
				NumUniqueVertsInBatch += NumNewUniqueVerts;
				NumTrisInBatch++;
			}
			if (NumTrisInBatch > 0)
			{
				BatchTriCounts.Add(NumTrisInBatch);
			}
		}
		
		// --- Packing based on calculated batches ---
		const int32 NumBatches = BatchTriCounts.Num();
		AppendBits(NumBatches, NumBatchCountBits);
		AppendBits(0, NumBatchCountBits); // For material range 1
		AppendBits(0, NumBatchCountBits); // For material range 2

		FString BatchLogString = FString::Printf(TEXT("Cluster[%d] Tris:%d -> Batches:%d ["), ClusterIndex, Cluster.NumTriangles(), NumBatches);

		for (int32 BatchIndex = 0; BatchIndex < NumBatches; ++BatchIndex)
		{
			const uint8 NumTrianglesInBatch = BatchTriCounts[BatchIndex];
			AppendBits(NumTrianglesInBatch - 1, NumTriCountBits);
			BatchLogString += FString::Printf(TEXT("%d"), NumTrianglesInBatch);
			if (BatchIndex < NumBatches - 1) BatchLogString += TEXT(", ");
		}
		BatchLogString += TEXT("]");

		// Resize BatchInfo to the actual number of DWORDS used
		const uint32 NumDwordsUsed = FMath::DivideAndRoundUp(BitOffset, 32u);
		BatchInfo.SetNum(NumDwordsUsed, EAllowShrinking::No);

		FString BatchInfoString = "";
		for(uint32 Dword : BatchInfo)
		{
			BatchInfoString += FString::Printf(TEXT("0x%X "), Dword);
		}
		UE_LOG(LogTemp, Log, TEXT("%s -> BatchInfo: [ %s]"), *BatchLogString, *BatchInfoString);
		
		PackedCluster.SetVertResourceBatchInfo(BatchInfo, 0, 1);
	}

... //other stuff here
}`

You'll also need to pass around the materials indices cause I couldn't directly store them inside FStaticMeshRenderData if I remember correctly ... maybe I'm still missing something ...

So I had to change these signatures :

static void ApplyRenderData(UStaticMesh& StaticMesh, TUniquePtr<FStaticMeshRenderData> RenderData, const TArray<FStaticMaterial>& InMaterials); static UStaticMesh* CreateStaticMesh(TUniquePtr<FStaticMeshRenderData> RenderData, const TArray<FStaticMaterial>& InMaterials);

Also had to modify how the FCluster is packed :

`

FPackedCluster FCluster::Pack(const FEncodingInfo& Info) const
{
VOXEL_FUNCTION_COUNTER();

const FVoxelBox Bounds = GetBounds();

const float MaxEdgeLength = INLINE_LAMBDA
{
	VOXEL_SCOPE_COUNTER("MaxEdgeLength");

	float MaxEdgeLengthSquared = 0;
	for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles(); TriangleIndex++)
	{
		const FVector3f A = Positions[Indices[3 * TriangleIndex + 0]];
		const FVector3f B = Positions[Indices[3 * TriangleIndex + 1]];
		const FVector3f C = Positions[Indices[3 * TriangleIndex + 2]];

		MaxEdgeLengthSquared = FMath::Max(MaxEdgeLengthSquared, FVector3f::DistSquared(A, B));
		MaxEdgeLengthSquared = FMath::Max(MaxEdgeLengthSquared, FVector3f::DistSquared(B, C));
		MaxEdgeLengthSquared = FMath::Max(MaxEdgeLengthSquared, FVector3f::DistSquared(A, C));
	}
	return FMath::Sqrt(MaxEdgeLengthSquared);
};

FPackedCluster Result;
FMemory::Memzero(Result);

Result.SetNumVerts(NumVertices());
Result.SetNumTris(NumTriangles());

if (Colors.Num() == 0)
{
    Result.SetColorMode(NANITE_VERTEX_COLOR_MODE_CONSTANT);
    Result.ColorMin = FColor::White.ToPackedABGR();
}
else if (Info.ColorBits == FIntVector4(0))
{
    Result.SetColorMode(NANITE_VERTEX_COLOR_MODE_CONSTANT);
    Result.ColorMin = Info.ColorMin.ToPackedABGR();
}
else
{
    Result.SetColorMode(NANITE_VERTEX_COLOR_MODE_VARIABLE);
    Result.SetColorBitsR(Info.ColorBits.X);
    Result.SetColorBitsG(Info.ColorBits.Y);
    Result.SetColorBitsB(Info.ColorBits.Z);
    Result.SetColorBitsA(Info.ColorBits.W);
    Result.ColorMin = Info.ColorMin.ToPackedABGR();
}

 
Result.SetGroupIndex(MaterialIndex);

Result.SetBitsPerIndex(Info.BitsPerIndex);
Result.PosStart = Info.PositionMin;
Result.SetPosPrecision(Info.Settings.PositionPrecision);
Result.SetPosBitsX(Info.PositionBits.X);
Result.SetPosBitsY(Info.PositionBits.Y);
Result.SetPosBitsZ(Info.PositionBits.Z);

#if VOXEL_ENGINE_VERSION >= 506
Result.LODBounds = FSphere3f(FVector3f(Bounds.GetCenter()), Bounds.Size().Length());
#else
Result.LODBounds = FVector4f(FVector3f(Bounds.GetCenter()), Bounds.Size().Length());
#endif

Result.BoxBoundsCenter = FVector3f(Bounds.GetCenter());
Result.LODErrorAndEdgeLength = (uint32(FFloat16(0.1f).Encoded) << 0) | (uint32(FFloat16(MaxEdgeLength).Encoded) << 16);
Result.BoxBoundsExtent = FVector3f(Bounds.GetExtent());
Result.Flags = NANITE_CLUSTER_FLAG_STREAMING_LEAF | NANITE_CLUSTER_FLAG_ROOT_LEAF;

Result.SetBitsPerAttribute(Info.BitsPerAttribute);
Result.SetNormalPrecision(Info.Settings.NormalBits);
Result.SetHasTangents(false);
Result.SetNumUVs(TextureCoordinates.Num());

// ... Your UVBitOffsets packing is correct ...
uint32 BitOffset = 0;
for (int32 UVIndex = 0; UVIndex < TextureCoordinates.Num(); UVIndex++)
{
   Result.UVBitOffsets |= BitOffset << (UVIndex * 8);
   const FUVRange& UVRange = Info.UVRanges[UVIndex];
   BitOffset += UVRange.NumBits.X + UVRange.NumBits.Y;
}

// ===================================================================================
// Replicate the engine's PackMaterialFastPath for a single material range.
// ===================================================================================
const uint32 Material0Length = NumTriangles();
const uint32 Material0Index = MaterialIndex;
const uint32 Material1Length = 0;
const uint32 Material1Index = 0;
const uint32 Material2Index = 0;

check(Material0Index < 64);
check(Material0Length >= 1 && Material0Length <= 128);

Result.PackedMaterialInfo = 0;
Result.PackedMaterialInfo |= Material0Index;
Result.PackedMaterialInfo |= Material1Index << 6;
Result.PackedMaterialInfo |= Material2Index << 12;
Result.PackedMaterialInfo |= (Material0Length - 1u) << 18;
Result.PackedMaterialInfo |= Material1Length << 25;

// Log the packed value to verify
UE_LOG(LogTemp, Log, TEXT("FCluster::Pack - Final MaterialIndex: %u, NumTris: %u -> PackedMaterialInfo: 0x%X"), MaterialIndex, NumTriangles(), Result.PackedMaterialInfo);

return Result;

}

`

But I think that's more or less all ... Took me about a day of head scratching and understanding how nanite binary format is built ... I hope this puts you on track to properly implement it :))

Cheers !

[Phyronnaz]

That's great! I'll leave this issue open so people who want to do the same can look at what you did :)

Unfortunately this isn't something we need for Voxel Plugin so we might not merge it anytime soon