CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Developer/NaniteBuilder/Private/ClusterDAG.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

1064 lines
30 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "ClusterDAG.h"
#include "Async/Async.h"
#include "Async/ParallelFor.h"
#include "GraphPartitioner.h"
#include "BVHCluster.h"
#include "MeshSimplify.h"
namespace Nanite
{
void FClusterDAG::AddMesh(
const FConstMeshBuildVertexView& Verts,
TArrayView< const uint32 > Indexes,
TArrayView< const int32 > MaterialIndexes,
const FBounds3f& VertexBounds,
const FVertexFormat& VertexFormat )
{
TRACE_CPUPROFILER_EVENT_SCOPE(Nanite::Build::ClusterTriangles);
uint32 Time0 = FPlatformTime::Cycles();
LOG_CRC( Verts );
LOG_CRC( Indexes );
bHasSkinning |= VertexFormat.NumBoneInfluences > 0;
bHasTangents |= VertexFormat.bHasTangents;
bHasColors |= VertexFormat.bHasColors;
uint32 NumTriangles = Indexes.Num() / 3;
FAdjacency Adjacency( Indexes.Num() );
FEdgeHash EdgeHash( Indexes.Num() );
auto GetPosition = [ &Verts, &Indexes ]( uint32 EdgeIndex )
{
return Verts.Position[ Indexes[ EdgeIndex ] ];
};
ParallelFor( TEXT("Nanite.ClusterTriangles.PF"), Indexes.Num(), 4096,
[&]( int32 EdgeIndex )
{
EdgeHash.Add_Concurrent( EdgeIndex, GetPosition );
} );
ParallelFor( TEXT("Nanite.ClusterTriangles.PF"), Indexes.Num(), 1024,
[&]( int32 EdgeIndex )
{
int32 AdjIndex = -1;
int32 AdjCount = 0;
EdgeHash.ForAllMatching( EdgeIndex, false, GetPosition,
[&]( int32 EdgeIndex, int32 OtherEdgeIndex )
{
AdjIndex = OtherEdgeIndex;
AdjCount++;
} );
if( AdjCount > 1 )
AdjIndex = -2;
Adjacency.Direct[ EdgeIndex ] = AdjIndex;
} );
FDisjointSet DisjointSet( NumTriangles );
for( uint32 EdgeIndex = 0, Num = Indexes.Num(); EdgeIndex < Num; EdgeIndex++ )
{
if( Adjacency.Direct[ EdgeIndex ] == -2 )
{
// EdgeHash is built in parallel, so we need to sort before use to ensure determinism.
// This path is only executed in the rare event that an edge is shared by more than two triangles,
// so performance impact should be negligible in practice.
TArray< TPair< int32, int32 >, TInlineAllocator< 16 > > Edges;
EdgeHash.ForAllMatching( EdgeIndex, false, GetPosition,
[&]( int32 EdgeIndex0, int32 EdgeIndex1 )
{
Edges.Emplace( EdgeIndex0, EdgeIndex1 );
} );
Edges.Sort();
for( const TPair< int32, int32 >& Edge : Edges )
{
Adjacency.Link( Edge.Key, Edge.Value );
}
}
Adjacency.ForAll( EdgeIndex,
[&]( int32 EdgeIndex0, int32 EdgeIndex1 )
{
if( EdgeIndex0 > EdgeIndex1 )
DisjointSet.UnionSequential( EdgeIndex0 / 3, EdgeIndex1 / 3 );
} );
}
uint32 BoundaryTime = FPlatformTime::Cycles();
UE_LOG( LogStaticMesh, Log,
TEXT("Adjacency [%.2fs], tris: %i, UVs %i%s%s"),
FPlatformTime::ToMilliseconds( BoundaryTime - Time0 ) / 1000.0f,
Indexes.Num() / 3,
VertexFormat.NumTexCoords,
VertexFormat.bHasTangents ? TEXT(", Tangents") : TEXT(""),
VertexFormat.bHasColors ? TEXT(", Color") : TEXT("") );
#if 0//NANITE_VOXEL_DATA
FBVHCluster Partitioner( NumTriangles, FCluster::ClusterSize - 4, FCluster::ClusterSize );
{
TRACE_CPUPROFILER_EVENT_SCOPE(Nanite::Build::PartitionGraph);
Partitioner.Build(
[ &Verts, &Indexes ]( uint32 TriIndex )
{
FBounds3f Bounds;
Bounds = Verts.Position[ Indexes[ TriIndex * 3 + 0 ] ];
Bounds += Verts.Position[ Indexes[ TriIndex * 3 + 1 ] ];
Bounds += Verts.Position[ Indexes[ TriIndex * 3 + 2 ] ];
return Bounds;
} );
check( Partitioner.Ranges.Num() );
LOG_CRC( Partitioner.Ranges );
}
#else
FGraphPartitioner Partitioner( NumTriangles, FCluster::ClusterSize - 4, FCluster::ClusterSize );
{
TRACE_CPUPROFILER_EVENT_SCOPE(Nanite::Build::PartitionGraph);
auto GetCenter = [ &Verts, &Indexes ]( uint32 TriIndex )
{
FVector3f Center;
Center = Verts.Position[ Indexes[ TriIndex * 3 + 0 ] ];
Center += Verts.Position[ Indexes[ TriIndex * 3 + 1 ] ];
Center += Verts.Position[ Indexes[ TriIndex * 3 + 2 ] ];
return Center * (1.0f / 3.0f);
};
Partitioner.BuildLocalityLinks( DisjointSet, VertexBounds, MaterialIndexes, GetCenter );
auto* RESTRICT Graph = Partitioner.NewGraph( NumTriangles * 3 );
for( uint32 i = 0; i < NumTriangles; i++ )
{
Graph->AdjacencyOffset[i] = Graph->Adjacency.Num();
uint32 TriIndex = Partitioner.Indexes[i];
for( int k = 0; k < 3; k++ )
{
Adjacency.ForAll( 3 * TriIndex + k,
[ &Partitioner, Graph ]( int32 EdgeIndex, int32 AdjIndex )
{
Partitioner.AddAdjacency( Graph, AdjIndex / 3, 4 * 65 );
} );
}
Partitioner.AddLocalityLinks( Graph, TriIndex, 1 );
}
Graph->AdjacencyOffset[ NumTriangles ] = Graph->Adjacency.Num();
bool bSingleThreaded = NumTriangles < 5000;
Partitioner.PartitionStrict( Graph, !bSingleThreaded );
check( Partitioner.Ranges.Num() );
LOG_CRC( Partitioner.Ranges );
}
#endif
const uint32 OptimalNumClusters = FMath::DivideAndRoundUp< int32 >( Indexes.Num(), FCluster::ClusterSize * 3 );
uint32 ClusterTime = FPlatformTime::Cycles();
UE_LOG( LogStaticMesh, Log, TEXT("Clustering [%.2fs]. Ratio: %f"), FPlatformTime::ToMilliseconds( ClusterTime - BoundaryTime ) / 1000.0f, (float)Partitioner.Ranges.Num() / (float)OptimalNumClusters );
const uint32 BaseCluster = Clusters.Num();
Clusters.AddDefaulted( Partitioner.Ranges.Num() );
{
TRACE_CPUPROFILER_EVENT_SCOPE(Nanite::Build::BuildClusters);
ParallelFor( TEXT("Nanite.BuildClusters.PF"), Partitioner.Ranges.Num(), 1024,
[&]( int32 Index )
{
auto& Range = Partitioner.Ranges[ Index ];
Clusters[ BaseCluster + Index ] = FCluster(
Verts,
Indexes,
MaterialIndexes,
VertexFormat,
Range.Begin, Range.End,
Partitioner.Indexes, Partitioner.SortedTo, Adjacency );
// Negative notes it's a leaf
Clusters[ BaseCluster + Index ].EdgeLength *= -1.0f;
});
}
uint32 LeavesTime = FPlatformTime::Cycles();
UE_LOG( LogStaticMesh, Log, TEXT("Leaves [%.2fs]"), FPlatformTime::ToMilliseconds( LeavesTime - ClusterTime ) / 1000.0f );
}
static const uint32 MinGroupSize = 8;
static const uint32 MaxGroupSize = 32;
void FClusterDAG::ReduceMesh( uint32 ClusterRangeStart, uint32 ClusterRangeNum, uint32 MeshIndex )
{
TRACE_CPUPROFILER_EVENT_SCOPE(Nanite::Build::DAG.ReduceMesh);
if( ClusterRangeNum == 0 )
{
return;
}
TUniquePtr<FRayTracingScene> RayTracingScene;
#if NANITE_VOXEL_DATA
if( Settings.bPreserveArea )
{
RayTracingScene = MakeUnique< FRayTracingScene >( Clusters, ClusterRangeStart, ClusterRangeNum );
}
#endif
uint32 LevelOffset = ClusterRangeStart;
TAtomic< uint32 > NumClusters( Clusters.Num() );
bool bFirstLevel = true;
UE::Tasks::FCancellationToken* CancellationToken = UE::Tasks::FCancellationTokenScope::GetCurrentCancellationToken();
while( true )
{
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
TArrayView< FCluster > LevelClusters( &Clusters[ LevelOffset ], bFirstLevel ? ClusterRangeNum : (Clusters.Num() - LevelOffset) );
bFirstLevel = false;
uint32 NumExternalEdges = 0;
float MinError = +MAX_flt;
float MaxError = -MAX_flt;
float AvgError = 0.0f;
for( FCluster& Cluster : LevelClusters )
{
NumExternalEdges += Cluster.NumExternalEdges;
TotalBounds += Cluster.Bounds;
MinError = FMath::Min( MinError, Cluster.LODError );
MaxError = FMath::Max( MaxError, Cluster.LODError );
AvgError += Cluster.LODError;
}
AvgError /= (float)LevelClusters.Num();
UE_LOG( LogStaticMesh, Verbose, TEXT("Num clusters %i. Error %.4f, %.4f, %.4f"), LevelClusters.Num(), MinError, AvgError, MaxError );
uint32 MaxClusterSize = FCluster::ClusterSize;
if( LevelClusters.Num() < 2 )
{
if( LevelClusters[0].NumTris )
{
break;
}
else if( LevelClusters[0].MaterialIndexes.Num() > 64 )
{
MaxClusterSize = 64;
}
else if( LevelClusters[0].MaterialIndexes.Num() > 32 )
{
MaxClusterSize = 32;
}
else
{
break;
}
}
if( LevelClusters.Num() <= MaxGroupSize )
{
TArray< uint32, TInlineAllocator< MaxGroupSize > > Children;
uint32 NumGroupElements = 0;
for( FCluster& Cluster : LevelClusters )
{
NumGroupElements += Cluster.MaterialIndexes.Num();
Children.Add( LevelOffset++ );
}
uint32 MaxParents = FMath::DivideAndRoundUp( NumGroupElements, MaxClusterSize * 2 );
LevelOffset = Clusters.Num();
Clusters.AddDefaulted( MaxParents );
Groups.AddDefaulted( 1 );
ReduceGroup( RayTracingScene.Get(), NumClusters, Children, MaxClusterSize, MaxParents, Groups.Num() - 1, MeshIndex );
check( LevelOffset < NumClusters );
// Correct num to atomic count
Clusters.SetNum( NumClusters, EAllowShrinking::No );
continue;
}
struct FExternalEdge
{
uint32 ClusterIndex;
int32 EdgeIndex;
};
TArray< FExternalEdge > ExternalEdges;
FHashTable ExternalEdgeHash;
TAtomic< uint32 > ExternalEdgeOffset(0);
// We have a total count of NumExternalEdges so we can allocate a hash table without growing.
ExternalEdges.AddUninitialized( NumExternalEdges );
ExternalEdgeHash.Clear( 1 << FMath::FloorLog2( NumExternalEdges ), NumExternalEdges );
// Add edges to hash table
ParallelFor( TEXT("Nanite.BuildDAG.PF"), LevelClusters.Num(), 32,
[&]( uint32 ClusterIndex )
{
FCluster& Cluster = LevelClusters[ ClusterIndex ];
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
for( int32 EdgeIndex = 0; EdgeIndex < Cluster.ExternalEdges.Num(); EdgeIndex++ )
{
if( Cluster.ExternalEdges[ EdgeIndex ] )
{
uint32 VertIndex0 = Cluster.Indexes[ EdgeIndex ];
uint32 VertIndex1 = Cluster.Indexes[ Cycle3( EdgeIndex ) ];
const FVector3f& Position0 = Cluster.GetPosition( VertIndex0 );
const FVector3f& Position1 = Cluster.GetPosition( VertIndex1 );
uint32 Hash0 = HashPosition( Position0 );
uint32 Hash1 = HashPosition( Position1 );
uint32 Hash = Murmur32( { Hash0, Hash1 } );
uint32 ExternalEdgeIndex = ExternalEdgeOffset++;
ExternalEdges[ ExternalEdgeIndex ] = { ClusterIndex, EdgeIndex };
ExternalEdgeHash.Add_Concurrent( Hash, ExternalEdgeIndex );
}
}
});
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
check( ExternalEdgeOffset == ExternalEdges.Num() );
TAtomic< uint32 > NumAdjacency(0);
// Find matching edge in other clusters
ParallelFor( TEXT("Nanite.BuildDAG.PF"), LevelClusters.Num(), 32,
[&]( uint32 ClusterIndex )
{
FCluster& Cluster = LevelClusters[ ClusterIndex ];
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
for( int32 EdgeIndex = 0; EdgeIndex < Cluster.ExternalEdges.Num(); EdgeIndex++ )
{
if( Cluster.ExternalEdges[ EdgeIndex ] )
{
uint32 VertIndex0 = Cluster.Indexes[ EdgeIndex ];
uint32 VertIndex1 = Cluster.Indexes[ Cycle3( EdgeIndex ) ];
const FVector3f& Position0 = Cluster.GetPosition( VertIndex0 );
const FVector3f& Position1 = Cluster.GetPosition( VertIndex1 );
uint32 Hash0 = HashPosition( Position0 );
uint32 Hash1 = HashPosition( Position1 );
uint32 Hash = Murmur32( { Hash1, Hash0 } );
for( uint32 ExternalEdgeIndex = ExternalEdgeHash.First( Hash ); ExternalEdgeHash.IsValid( ExternalEdgeIndex ); ExternalEdgeIndex = ExternalEdgeHash.Next( ExternalEdgeIndex ) )
{
FExternalEdge ExternalEdge = ExternalEdges[ ExternalEdgeIndex ];
FCluster& OtherCluster = LevelClusters[ ExternalEdge.ClusterIndex ];
if( OtherCluster.ExternalEdges[ ExternalEdge.EdgeIndex ] )
{
uint32 OtherVertIndex0 = OtherCluster.Indexes[ ExternalEdge.EdgeIndex ];
uint32 OtherVertIndex1 = OtherCluster.Indexes[ Cycle3( ExternalEdge.EdgeIndex ) ];
if( Position0 == OtherCluster.GetPosition( OtherVertIndex1 ) &&
Position1 == OtherCluster.GetPosition( OtherVertIndex0 ) )
{
if( ClusterIndex != ExternalEdge.ClusterIndex )
{
// Increase it's count
Cluster.AdjacentClusters.FindOrAdd( ExternalEdge.ClusterIndex, 0 )++;
// Can't break or a triple edge might be non-deterministically connected.
// Need to find all matching, not just first.
}
}
}
}
}
}
NumAdjacency += Cluster.AdjacentClusters.Num();
// Force deterministic order of adjacency.
Cluster.AdjacentClusters.KeySort(
[ &LevelClusters ]( uint32 A, uint32 B )
{
return LevelClusters[A].GUID < LevelClusters[B].GUID;
} );
});
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
FDisjointSet DisjointSet( LevelClusters.Num() );
for( uint32 ClusterIndex = 0; ClusterIndex < (uint32)LevelClusters.Num(); ClusterIndex++ )
{
for( auto& Pair : LevelClusters[ ClusterIndex ].AdjacentClusters )
{
uint32 OtherClusterIndex = Pair.Key;
uint32 Count = LevelClusters[ OtherClusterIndex ].AdjacentClusters.FindChecked( ClusterIndex );
check( Count == Pair.Value );
if( ClusterIndex > OtherClusterIndex )
{
DisjointSet.UnionSequential( ClusterIndex, OtherClusterIndex );
}
}
}
FGraphPartitioner Partitioner( LevelClusters.Num(), MinGroupSize, MaxGroupSize );
auto GetCenter = [&]( uint32 Index )
{
FBounds3f& Bounds = LevelClusters[ Index ].Bounds;
return 0.5f * ( Bounds.Min + Bounds.Max );
};
Partitioner.BuildLocalityLinks( DisjointSet, TotalBounds, TArrayView< const int32 >(), GetCenter );
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
auto* RESTRICT Graph = Partitioner.NewGraph( NumAdjacency );
for( int32 i = 0; i < LevelClusters.Num(); i++ )
{
Graph->AdjacencyOffset[i] = Graph->Adjacency.Num();
uint32 ClusterIndex = Partitioner.Indexes[i];
for( auto& Pair : LevelClusters[ ClusterIndex ].AdjacentClusters )
{
uint32 OtherClusterIndex = Pair.Key;
uint32 NumSharedEdges = Pair.Value;
const auto& Cluster0 = Clusters[ LevelOffset + ClusterIndex ];
const auto& Cluster1 = Clusters[ LevelOffset + OtherClusterIndex ];
bool bSiblings = Cluster0.GroupIndex != MAX_uint32 && Cluster0.GroupIndex == Cluster1.GroupIndex;
Partitioner.AddAdjacency( Graph, OtherClusterIndex, NumSharedEdges * ( bSiblings ? 1 : 16 ) + 4 );
}
Partitioner.AddLocalityLinks( Graph, ClusterIndex, 1 );
}
Graph->AdjacencyOffset[ Graph->Num ] = Graph->Adjacency.Num();
LOG_CRC( Graph->Adjacency );
LOG_CRC( Graph->AdjacencyCost );
LOG_CRC( Graph->AdjacencyOffset );
bool bSingleThreaded = LevelClusters.Num() <= 32;
Partitioner.PartitionStrict( Graph, !bSingleThreaded );
LOG_CRC( Partitioner.Ranges );
uint32 MaxParents = 0;
for( auto& Range : Partitioner.Ranges )
{
uint32 NumGroupElements = 0;
for( uint32 i = Range.Begin; i < Range.End; i++ )
{
// Global indexing is needed in Reduce()
Partitioner.Indexes[i] += LevelOffset;
NumGroupElements += Clusters[ Partitioner.Indexes[i] ].MaterialIndexes.Num();
}
MaxParents += FMath::DivideAndRoundUp( NumGroupElements, MaxClusterSize * 2 );
}
LevelOffset = Clusters.Num();
Clusters.AddDefaulted( MaxParents );
Groups.AddDefaulted( Partitioner.Ranges.Num() );
ParallelFor( TEXT("Nanite.BuildDAG.PF"), Partitioner.Ranges.Num(), 1,
[&]( int32 PartitionIndex )
{
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
auto& Range = Partitioner.Ranges[ PartitionIndex ];
TArrayView< uint32 > Children( &Partitioner.Indexes[ Range.Begin ], Range.End - Range.Begin );
uint32 NumGroupElements = 0;
for( uint32 i = Range.Begin; i < Range.End; i++ )
{
NumGroupElements += Clusters[ Partitioner.Indexes[i] ].MaterialIndexes.Num();
}
uint32 MaxParents = FMath::DivideAndRoundUp( NumGroupElements, MaxClusterSize * 2 );
uint32 ClusterGroupIndex = PartitionIndex + Groups.Num() - Partitioner.Ranges.Num();
ReduceGroup( RayTracingScene.Get(), NumClusters, Children, MaxClusterSize, MaxParents, ClusterGroupIndex, MeshIndex );
} );
if (CancellationToken && CancellationToken->IsCanceled())
{
return;
}
check( LevelOffset < NumClusters );
// Correct num to atomic count
Clusters.SetNum( NumClusters, EAllowShrinking::No );
// Force a deterministic order of the generated parent clusters
{
// TODO: Optimize me.
// Just sorting the array directly seems like the safest option at this stage (right before UE5 final build).
// On AOD_Shield this seems to be on the order of 0.01s in practice.
// As the Clusters array is already conservatively allocated, it seems storing the parent clusters in their designated
// conservative ranges and then doing a compaction pass at the end would be a more efficient solution that doesn't involve sorting.
//uint32 StartTime = FPlatformTime::Cycles();
TArrayView< FCluster > Parents( &Clusters[ LevelOffset ], Clusters.Num() - LevelOffset );
Parents.Sort(
[&]( const FCluster& A, const FCluster& B )
{
return A.GUID < B.GUID;
} );
//UE_LOG(LogStaticMesh, Log, TEXT("SortTime Adjacency [%.2fs]"), FPlatformTime::ToMilliseconds(FPlatformTime::Cycles() - StartTime) / 1000.0f);
}
}
#if RAY_TRACE_VOXELS
for( FCluster& Cluster : Clusters )
{
Cluster.ExtraVoxels.Empty(); // VOXELTODO: Free this earlier
}
#endif
// Max out root node
uint32 RootIndex = LevelOffset;
FClusterGroup RootClusterGroup;
RootClusterGroup.Children.Add( RootIndex );
RootClusterGroup.Bounds = Clusters[ RootIndex ].SphereBounds;
RootClusterGroup.LODBounds = FSphere3f( 0 );
RootClusterGroup.MaxParentLODError = 1e10f;
RootClusterGroup.MinLODError = -1.0f;
RootClusterGroup.MipLevel = Clusters[ RootIndex ].MipLevel + 1;
RootClusterGroup.MeshIndex = MeshIndex;
RootClusterGroup.AssemblyPartIndex = MAX_uint32;
RootClusterGroup.bTrimmed = false;
Clusters[ RootIndex ].GroupIndex = Groups.Num();
Groups.Add( RootClusterGroup );
}
float InverseLerp(
float y,
float x0, float y0,
float x1, float y1 )
{
return ( x0 * (y1 - y) - x1 * (y0 - y) ) / ( y1 - y0 );
}
float InverseLerp(
float y,
float x0, float y0,
float x1, float y1,
float x2, float y2 )
{
// Inverse quadratic interpolation
#if 0
float a = (y0 - y) * (x1 - x0) * (y1 - y2);
float b = (y1 - y) * (x1 - x2) * (x1 - x0) * (y2 - y0);
float c = (y2 - y) * (x1 - x2) * (y0 - y1);
return x1 + b / (a + c);
#else
return
(y - y1) * (y - y2) * x0 / ( (y0 - y1) * (y0 - y2) ) +
(y - y2) * (y - y0) * x1 / ( (y1 - y2) * (y1 - y0) ) +
(y - y0) * (y - y1) * x2 / ( (y2 - y0) * (y2 - y1) );
#endif
}
// Brent's method
template< typename FuncType >
float BrentRootFind(
float y, float Tolerance,
float xA, float yA,
float xB, float yB,
float xGuess, bool bInitialGuess,
int32 MaxIter,
FuncType&& Func )
{
if( FMath::Abs( yA - y ) < FMath::Abs( yB - y ) )
{
Swap( xA, xB );
Swap( yA, yB );
}
float xC = xA;
float yC = yA;
float xD = xA;
bool bBisection = true;
for( int32 i = 0; i < MaxIter; i++ )
{
if( FMath::Abs( xB - xA ) < SMALL_NUMBER ||
FMath::Abs( yB - y ) <= Tolerance )
break;
if( yC != yA && yC != yB )
{
xGuess = InverseLerp(
y,
xA, yA,
xB, yB,
xC, yC );
}
else if( !bInitialGuess )
{
xGuess = InverseLerp(
y,
xA, yA,
xB, yB );
}
bInitialGuess = false;
if( bBisection )
{
bBisection =
FMath::Abs( xGuess - xB ) >= 0.5f * FMath::Abs( xB - xC ) ||
FMath::Abs( xB - xC ) < SMALL_NUMBER;
}
else
{
bBisection =
FMath::Abs( xGuess - xB ) >= 0.5f * FMath::Abs( xC - xD ) ||
FMath::Abs( xC - xD ) < SMALL_NUMBER;
}
// Outside of interval
if( ( xGuess - ( 0.75f * xA + 0.25f * xB ) ) * ( xGuess - xB ) >= 0.0f )
bBisection = true;
if( bBisection )
xGuess = 0.5f * ( xA + xB );
float yGuess = Func( xGuess );
xD = xC;
xC = xB;
yC = yB;
if( ( yA - y ) * ( yGuess - y ) < 0.0f )
{
xB = xGuess;
yB = yGuess;
}
else
{
xA = xGuess;
yA = yGuess;
}
if( FMath::Abs( yA - y ) < FMath::Abs( yB - y ) )
{
Swap( xA, xB );
Swap( yA, yB );
}
}
return xB;
}
template< typename FPartitioner, typename FPartitionFunc >
bool SplitCluster( FCluster& Merged, TArray< FCluster >& Clusters, TAtomic< uint32 >& NumClusters, uint32 MaxClusterSize, uint32& NumParents, uint32& ParentStart, uint32& ParentEnd, FPartitionFunc&& PartitionFunc )
{
if( Merged.MaterialIndexes.Num() <= (int32)MaxClusterSize )
{
ParentEnd = ( NumClusters += 1 );
ParentStart = ParentEnd - 1;
Clusters[ ParentStart ] = Merged;
Clusters[ ParentStart ].Bound();
return true;
}
else if( NumParents > 1 )
{
check( MaxClusterSize == FCluster::ClusterSize );
FAdjacency Adjacency = Merged.BuildAdjacency();
FPartitioner Partitioner( Merged.MaterialIndexes.Num(), MaxClusterSize - 4, MaxClusterSize );
PartitionFunc( Partitioner, Adjacency );
if( Partitioner.Ranges.Num() <= (int32)NumParents )
{
NumParents = Partitioner.Ranges.Num();
ParentEnd = ( NumClusters += NumParents );
ParentStart = ParentEnd - NumParents;
int32 Parent = ParentStart;
for( auto& Range : Partitioner.Ranges )
{
Clusters[ Parent ] = FCluster( Merged, Range.Begin, Range.End, Partitioner.Indexes, Partitioner.SortedTo, Adjacency );
Parent++;
}
return true;
}
}
return false;
}
void FClusterDAG::ReduceGroup( FRayTracingScene* RayTracingScene, TAtomic< uint32 >& NumClusters, TArrayView< uint32 > Children, uint32 MaxClusterSize, uint32 NumParents, int32 GroupIndex, uint32 MeshIndex )
{
check( GroupIndex >= 0 );
bool bAnyTriangles = false;
bool bAllTriangles = true;
TArray< FSphere3f, TInlineAllocator< MaxGroupSize > > Children_LODBounds;
TArray< FSphere3f, TInlineAllocator< MaxGroupSize > > Children_SphereBounds;
float ChildMinLODError = MAX_flt;
float ChildMaxLODError = 0.0f;
for( uint32 Child : Children )
{
FCluster& Cluster = Clusters[ Child ];
bAnyTriangles = bAnyTriangles || Cluster.NumTris > 0;
bAllTriangles = bAllTriangles && Cluster.NumTris > 0;
bool bLeaf = Cluster.EdgeLength < 0.0f;
float LODError = Cluster.LODError;
// Force monotonic nesting.
Children_LODBounds.Add( Cluster.LODBounds );
Children_SphereBounds.Add( Cluster.SphereBounds );
ChildMinLODError = FMath::Min( ChildMinLODError, bLeaf ? -1.0f : LODError );
ChildMaxLODError = FMath::Max( ChildMaxLODError, LODError );
Cluster.GroupIndex = GroupIndex;
Groups[ GroupIndex ].Children.Add( Child );
check( Groups[ GroupIndex ].Children.Num() <= NANITE_MAX_CLUSTERS_PER_GROUP_TARGET );
}
FSphere3f ParentLODBounds( Children_LODBounds.GetData(), Children_LODBounds.Num() );
FSphere3f ParentBounds( Children_SphereBounds.GetData(), Children_SphereBounds.Num() );
uint32 ParentStart = 0;
uint32 ParentEnd = 0;
FCluster Merged;
float SimplifyError = MAX_flt;
bool bVoxels = false;
#if NANITE_VOXEL_DATA
FCluster& FirstCluster = Clusters[ Children[0] ];
bVoxels = !bAllTriangles || Settings.bPreserveArea;
#endif
uint32 TargetClusterSize = MaxClusterSize - 2;
if( bAllTriangles )
{
uint32 TargetNumTris = NumParents * TargetClusterSize;
#if NANITE_VOXEL_DATA
if( !bVoxels ||
Settings.VoxelLevel == 0 ||
Settings.VoxelLevel > FirstCluster.MipLevel + 1 )
#endif
{
Merged = FCluster( *this, Children );
SimplifyError = Merged.Simplify( *this, TargetNumTris );
}
}
#if NANITE_VOXEL_DATA
if( bVoxels )
{
uint32 TotalVerts = 0;
float SurfaceArea = 0.0f;
for( uint32 Child : Children )
{
TotalVerts += Clusters[ Child ].NumVerts;
SurfaceArea += Clusters[ Child ].SurfaceArea;
}
int32 TargetNumBricks = NumParents * MaxClusterSize;
//uint32 TargetNumVoxels = TargetNumBricks * 16;
uint32 TargetNumVoxels = ( TotalVerts * 3 ) / 4;
float VoxelSize = FMath::Sqrt( SurfaceArea / TargetNumVoxels );
VoxelSize *= 0.75f;
VoxelSize = FMath::Max( VoxelSize, ChildMaxLODError );
#if 0
// Round to pow2
// = exp2( floor( log2(x) + 0.5 ) )
FFloat32 VoxelSizeF( VoxelSize * UE_SQRT_2 );
VoxelSizeF.Components.Mantissa = 0;
VoxelSize = VoxelSizeF.FloatValue;
#endif
float EstimatedVoxelSize = VoxelSize;
while( VoxelSize < SimplifyError )
{
FCluster Voxelized;
Voxelized.Voxelize( *this, *RayTracingScene, Children, VoxelSize );
if( Voxelized.NumVerts < TargetNumVoxels &&
Voxelized.Bricks.Num() < TargetNumBricks )
{
bool bSplitSuccess = SplitCluster< FBVHCluster >( Voxelized, Clusters, NumClusters, MaxClusterSize, NumParents, ParentStart, ParentEnd,
[ &Voxelized ]( FBVHCluster& Partitioner, FAdjacency& Adjacency )
{
Partitioner.Build(
[ &Voxelized ]( uint32 VertIndex )
{
FBounds3f Bounds;
Bounds = FVector3f( Voxelized.Bricks[ VertIndex ].Position );
return Bounds;
} );
} );
#if RAY_TRACE_VOXELS
if( Voxelized.NumTris == 0 )
{
// Distribute extra voxels to closest clusters
for( const FVector3f& Position : Voxelized.ExtraVoxels )
{
float BestDistance = MAX_flt;
uint32 BestParentIndex = 0xFFFFFFFFu;
for( uint32 ParentIndex = ParentStart; ParentIndex < ParentEnd; ParentIndex++ )
{
FVector3f BoundsCenter = Clusters[ ParentIndex ].Bounds.GetCenter();
float Distance = ( Position - BoundsCenter ).GetAbsMax();
if( Distance < BestDistance )
{
BestDistance = Distance;
BestParentIndex = ParentIndex;
}
}
Clusters[ BestParentIndex ].ExtraVoxels.Add( Position );
}
}
#endif
check( bSplitSuccess );
break;
}
VoxelSize *= 1.1f;
}
if( VoxelSize < SimplifyError )
SimplifyError = VoxelSize;
else
bVoxels = false;
}
#endif
if( !bVoxels )
{
check( bAllTriangles );
while(1)
{
bool bSplitSuccess = SplitCluster< FGraphPartitioner >( Merged, Clusters, NumClusters, MaxClusterSize, NumParents, ParentStart, ParentEnd,
[ &Merged ]( FGraphPartitioner& Partitioner, FAdjacency& Adjacency )
{
Merged.Split( Partitioner, Adjacency );
} );
if( bSplitSuccess )
break;
TargetClusterSize -= 2;
if( TargetClusterSize <= MaxClusterSize / 2 )
break;
uint32 TargetNumTris = NumParents * TargetClusterSize;
// Start over from scratch. Continuing from simplified cluster screws up ExternalEdges and LODError.
Merged = FCluster( *this, Children );
SimplifyError = Merged.Simplify( *this, TargetNumTris );
}
}
float ParentMaxLODError = FMath::Max( ChildMaxLODError, SimplifyError );
// Force parents to have same LOD data. They are all dependent.
for( uint32 Parent = ParentStart; Parent < ParentEnd; Parent++ )
{
Clusters[ Parent ].LODBounds = ParentLODBounds;
Clusters[ Parent ].LODError = ParentMaxLODError;
Clusters[ Parent ].GeneratingGroupIndex = GroupIndex;
}
Groups[ GroupIndex ].Bounds = ParentBounds;
Groups[ GroupIndex ].LODBounds = ParentLODBounds;
Groups[ GroupIndex ].MinLODError = ChildMinLODError;
Groups[ GroupIndex ].MaxParentLODError = ParentMaxLODError;
Groups[ GroupIndex ].MipLevel = Clusters[ Children[0] ].MipLevel;
Groups[ GroupIndex ].MeshIndex = MeshIndex;
Groups[ GroupIndex ].AssemblyPartIndex = MAX_uint32;
Groups[ GroupIndex ].bTrimmed = false;
}
FBinaryHeap< float > FClusterDAG::FindCut(
uint32 TargetNumTris,
float TargetError,
uint32 TargetOvershoot,
TBitArray<>* SelectedGroupsMask ) const
{
const FClusterGroup& RootGroup = Groups.Last();
const FCluster& RootCluster = Clusters[ RootGroup.Children[0] ];
bool bHitTargetBefore = false;
float MinError = RootCluster.LODError;
TBitArray<> VisitedGroups;
VisitedGroups.Init(false, Groups.Num());
VisitedGroups[Groups.Num() - 1] = true;
FBinaryHeap< float > Heap;
Heap.Add( -RootCluster.LODError, RootGroup.Children[0] );
uint32 CurNumTris = RootCluster.NumTris;
while( true )
{
// Grab highest error cluster to replace to reduce cut error
const uint32 ClusterIndex = Heap.Top();
const FCluster& Cluster = Clusters[ ClusterIndex ];
const FClusterGroup& Group = Groups[ Cluster.GroupIndex ];
const uint32 NumInstances = Group.AssemblyPartIndex == MAX_uint32 ? 1u : AssemblyPartData[ Group.AssemblyPartIndex ].NumTransforms;
if( Cluster.MipLevel == 0 )
break;
if( Cluster.GeneratingGroupIndex == MAX_uint32 )
break;
bool bHitTarget = CurNumTris > TargetNumTris || MinError < TargetError;
// Overshoot the target by TargetOvershoot number of triangles. This allows granular edge collapses to better minimize error to the target.
if( TargetOvershoot > 0 && bHitTarget && !bHitTargetBefore )
{
TargetNumTris = CurNumTris + TargetOvershoot;
bHitTarget = false;
bHitTargetBefore = true;
}
if( bHitTarget && Cluster.LODError < MinError )
break;
Heap.Pop();
CurNumTris -= Cluster.NumTris * NumInstances;
check( Cluster.LODError <= MinError );
MinError = Cluster.LODError;
if (VisitedGroups[Cluster.GeneratingGroupIndex])
{
continue;
}
VisitedGroups[Cluster.GeneratingGroupIndex] = true;
const FClusterGroup& NextGroup = Groups[ Cluster.GeneratingGroupIndex ];
const uint32 NextNumInstances = NextGroup.AssemblyPartIndex == MAX_uint32 ? 1u : AssemblyPartData[ NextGroup.AssemblyPartIndex ].NumTransforms;
for( uint32 Child : NextGroup.Children )
{
if( !Heap.IsPresent( Child ) )
{
const FCluster& ChildCluster = Clusters[ Child ];
check( ChildCluster.MipLevel < Cluster.MipLevel );
check( ChildCluster.LODError <= MinError );
Heap.Add( -ChildCluster.LODError, Child );
CurNumTris += ChildCluster.NumTris * NextNumInstances;
}
}
// TODO: Nanite-Assemblies: Double-check this. I think we have to handle the case where we cross the threshold from the mip tail
// into the lower mips of assembly parts. I believe it's possible otherwise to get into a situation where some mip tail clusters
// that were generated by assembly parts are still present on the heap and now overlap with an instanced, higher LOD of the part.
// Maybe this can be solved simply by detecting when we're crossing that threshold here and removing all clusters from the heap
// whose generating group == NextGroup like this? Not sure if it covers all cases though.
if (Group.AssemblyPartIndex == MAX_uint32 && NextGroup.AssemblyPartIndex != MAX_uint32)
{
for (int32 OtherGroupIndex = 0; OtherGroupIndex < Groups.Num(); ++OtherGroupIndex)
{
const FClusterGroup& OtherGroup = Groups[OtherGroupIndex];
if (OtherGroup.MipLevel < Group.MipLevel)
{
// Skip over higher mip groups
continue;
}
for (uint32 OtherClusterIndex : OtherGroup.Children)
{
const FCluster& OtherCluster = Clusters[OtherClusterIndex];
if (Heap.IsPresent(OtherClusterIndex) &&
OtherCluster.GeneratingGroupIndex == Cluster.GeneratingGroupIndex)
{
Heap.Remove(OtherClusterIndex);
CurNumTris -= OtherCluster.NumTris;
}
}
}
}
}
if (SelectedGroupsMask)
{
*SelectedGroupsMask = MoveTemp(VisitedGroups);
}
return Heap;
}
} // namespace Nanite
Reference in New Issue View Git Blame Copy Permalink