UE中计：UE4合并静态网格体实例

已于 2023-11-28 19:51:03 修改
阅读量977 收藏 1
点赞数
文章标签： UE
于 2023-11-25 14:09:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zx1091515459/article/details/134613970
版权 
//.h
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static TArray<UWorld*> GetAllWorlds(UWorld* world = nullptr, bool bIncludeInWorld = true);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static void UniteTerms(UWorld* world);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static void UniteTermsAllWorlds();
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static FString GetDefaultPackageName(AActor* primitive);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static bool RunMerge(const FString& PackageName, TArray<UPrimitiveComponent*> primComponents);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static int32 InstancesMergeForWorld(UWorld* World, bool bSelect, bool simpleInstancesMerge = true);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static void MergeComponentsToInstances(AActor* parent, TArray<UPrimitiveComponent*> ComponentsToMerge, UWorld* World, bool bSelect = false, bool bActuallyMerge = true, bool bRemoveOriginal = false);
	static void DefaultMergeComponentsToInstances(TArray<UPrimitiveComponent*>& ComponentsToMerge, UWorld* World, bool bActuallyMerge = true, bool bRemoveOriginal = false);
	UFUNCTION(BlueprintCallable, Category = "SceneTool")
	static void PrepPakControl();

//.CPP
TMap<AActor*, TArray<UPrimitiveComponent*>> AddMergeComponents(TMap<AActor*, TArray<UPrimitiveComponent*>> map, TArray<AActor*> attachActors, AActor* parentObj, AActor* actor)
{
	TArray<AActor*> itemFloors;
	map.GetKeys(itemFloors);
	if (itemFloors.Contains(parentObj))
	{
		if (attachActors.Num() == 0)
		{
			auto itemstatic = Cast<UStaticMeshComponent>(actor->GetComponentByClass(UStaticMeshComponent::StaticClass()));
			map.Find(parentObj)->Add(itemstatic);
		}
	}
	else
	{
		if (attachActors.Num() == 0)
		{
			TArray<UPrimitiveComponent*> staticActors;
			auto itemstatic = Cast<UStaticMeshComponent>(actor->GetComponentByClass(UStaticMeshComponent::StaticClass()));
			if (itemstatic)
			{
				staticActors.Add(itemstatic);
			}
			map.Add(parentObj, staticActors);
		}
	}
	return map;
}

TArray<UWorld*> USceneToolHelper::GetAllWorlds(UWorld* world, bool bIncludeInWorld)
{
	TArray<UWorld*> AllWorlds;
	if (world == nullptr)
	{
		EditorLevelUtils::GetWorlds(GWorld, AllWorlds, bIncludeInWorld);
	}
	else
	{
		EditorLevelUtils::GetWorlds(world, AllWorlds, bIncludeInWorld);
	}
	return AllWorlds;
}

void USceneToolHelper::UniteTerms(UWorld* world)
{
	TArray<UPrimitiveComponent*> primComponents;
	TArray<FString> packageNames;

	TArray<AActor*> actors;
	UGameplayStatics::GetAllActorsOfClass(world, AActor::StaticClass(), actors);
	for (auto actor : actors)
	{
		TArray<UPrimitiveComponent*> itemPrimitives;
		actor->GetComponents<UPrimitiveComponent>(itemPrimitives);
		for (auto primitive : itemPrimitives)
		{
			if (!primComponents.Contains(primitive))
			{
				primComponents.Add(primitive);
			}
		}

		const FString DefaultPackageName = GetDefaultPackageName(actor);
		if (!packageNames.Contains(DefaultPackageName))
		{
			packageNames.Add(DefaultPackageName);
		}
	}
	for (auto packageName : packageNames)
	{
		const FString DefaultPackageName = packageName;
		if (DefaultPackageName.Len() > 0)
		{
			const FString DefaultPath = FPackageName::GetLongPackagePath(DefaultPackageName);
			const FString DefaultName = FPackageName::GetShortName(DefaultPackageName);

			// Initialize SaveAssetDialog config
			FSaveAssetDialogConfig SaveAssetDialogConfig;
			SaveAssetDialogConfig.DialogTitleOverride = LOCTEXT("CreateMergedActorTitle", "Create Merged Actor");
			SaveAssetDialogConfig.DefaultPath = DefaultPath;
			SaveAssetDialogConfig.DefaultAssetName = DefaultName;
			SaveAssetDialogConfig.ExistingAssetPolicy = ESaveAssetDialogExistingAssetPolicy::AllowButWarn;
			SaveAssetDialogConfig.AssetClassNames.Add(UStaticMesh::StaticClass()->GetClassPathName());

			FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
			FString SaveObjectPath = ContentBrowserModule.Get().CreateModalSaveAssetDialog(SaveAssetDialogConfig);
			if (!SaveObjectPath.IsEmpty())
			{
				const FString PackageName = FPackageName::ObjectPathToPackageName(SaveObjectPath);

				RunMerge(PackageName, primComponents);
			}
		}
		else
		{
			RunMerge(DefaultPackageName, primComponents);
		}
	}
}
void USceneToolHelper::UniteTermsAllWorlds()
{
	TArray<UWorld*> worlds = GetAllWorlds();
	TArray<UPrimitiveComponent*> primComponents;
	TArray<FString> packageNames;
	for (auto world : worlds)
	{
		TArray<AActor*> actors;
		UGameplayStatics::GetAllActorsOfClass(world, AActor::StaticClass(), actors);
		for (auto actor : actors)
		{
			TArray<UPrimitiveComponent*> itemPrimitives;
			actor->GetComponents<UPrimitiveComponent>(itemPrimitives);
			for (auto primitive : itemPrimitives)
			{
				if (!primComponents.Contains(primitive))
				{
					primComponents.Add(primitive);
				}
			}

			const FString DefaultPackageName = GetDefaultPackageName(actor);
			if (!packageNames.Contains(DefaultPackageName))
			{
				packageNames.Add(DefaultPackageName);
			}
		}
		for (auto packageName : packageNames)
		{
			const FString DefaultPackageName = packageName;
			if (DefaultPackageName.Len() > 0)
			{
				const FString DefaultPath = FPackageName::GetLongPackagePath(DefaultPackageName);
				const FString DefaultName = FPackageName::GetShortName(DefaultPackageName);

				// Initialize SaveAssetDialog config
				FSaveAssetDialogConfig SaveAssetDialogConfig;
				SaveAssetDialogConfig.DialogTitleOverride = LOCTEXT("CreateMergedActorTitle", "Create Merged Actor");
				SaveAssetDialogConfig.DefaultPath = DefaultPath;
				SaveAssetDialogConfig.DefaultAssetName = DefaultName;
				SaveAssetDialogConfig.ExistingAssetPolicy = ESaveAssetDialogExistingAssetPolicy::AllowButWarn;
				SaveAssetDialogConfig.AssetClassNames.Add(UStaticMesh::StaticClass()->GetClassPathName());

				FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
				FString SaveObjectPath = ContentBrowserModule.Get().CreateModalSaveAssetDialog(SaveAssetDialogConfig);
				if (!SaveObjectPath.IsEmpty())
				{
					const FString PackageName = FPackageName::ObjectPathToPackageName(SaveObjectPath);

					RunMerge(PackageName, primComponents);
				}
			}
			else
			{
				RunMerge(DefaultPackageName, primComponents);
			}
		}
	}
}

FString USceneToolHelper::GetDefaultPackageName(AActor* primitive)
{
	// USelection* SelectedActors = GEditor->GetSelectedActors();
	// // Iterate through selected actors and find first static mesh asset
	// // Use this static mesh path as destination package name for a merged mesh
	FString PackageName = FPackageName::FilenameToLongPackageName(FPaths::ProjectContentDir() + TEXT("SM_MERGED"));

	if (primitive)
	{
		FString ActorName = primitive->GetName();
		PackageName = FString::Printf(TEXT("%s_%s"), *PackageName, *ActorName);
	}

	if (PackageName.IsEmpty())
	{
		PackageName = MakeUniqueObjectName(NULL, UPackage::StaticClass(), *PackageName).ToString();
	}

	return PackageName;
}

bool USceneToolHelper::RunMerge(const FString& PackageName, TArray<UPrimitiveComponent*> primComponents)
{
	const IMeshMergeUtilities& MeshUtilities = FModuleManager::Get().LoadModuleChecked<IMeshMergeModule>("MeshMergeUtilities").GetUtilities();
	USelection* SelectedActors = GEditor->GetSelectedActors();
	TArray<AActor*> Actors;
	TArray<ULevel*> UniqueLevels;
	for (FSelectionIterator Iter(*SelectedActors); Iter; ++Iter)
	{
		AActor* Actor = Cast<AActor>(*Iter);
		if (Actor)
		{
			Actors.Add(Actor);
			UniqueLevels.AddUnique(Actor->GetLevel());
		}
	}

	// // This restriction is only for replacement of selected actors with merged mesh actor
	// if (UniqueLevels.Num() > 1 && bReplaceSourceActors)
	// {
	// 	FText Message = NSLOCTEXT("UnrealEd", "FailedToMergeActorsSublevels_Msg", "The selected actors should be in the same level");
	// 	const FText Title = NSLOCTEXT("UnrealEd", "FailedToMergeActors_Title", "Unable to merge actors");
	// 	FMessageDialog::Open(EAppMsgType::Ok, Message, &Title);
	// 	return false;
	// }

	FVector MergedActorLocation;
	TArray<UObject*> AssetsToSync;
	// Merge...
	{
		FScopedSlowTask SlowTask(0, LOCTEXT("MergingActorsSlowTask", "Merging actors..."));
		SlowTask.MakeDialog();

		TArray<UPrimitiveComponent*> ComponentsToMerge;

		for (auto PrimComponent : primComponents)
		{
			bool bShouldIncorporate = false; // Should default to part of merged mesh
			if (UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(PrimComponent))
			{
				bShouldIncorporate = (StaticMeshComponent->GetStaticMesh() != nullptr);
			}
			else if (UShapeComponent* ShapeComponent = Cast<UShapeComponent>(PrimComponent))
			{
				bShouldIncorporate = true;
			}
			// Determine whether or not this component should be incorporated according the user settings
			if (bShouldIncorporate && IsValid(PrimComponent))
			{
				ComponentsToMerge.Add(PrimComponent);
			}
		}

		if (ComponentsToMerge.Num())
		{
			UWorld* World = ComponentsToMerge[0]->GetWorld();
			checkf(World != nullptr, TEXT("Invalid World retrieved from Mesh components"));
			const float ScreenAreaSize = TNumericLimits<float>::Max();
			FMeshMergingSettings Setting;
			Setting.bMergePhysicsData = true;
			// In this case set to AllLODs value since calculating the LODs is not possible and thus disabled in the UI
			Setting.LODSelectionType = EMeshLODSelectionType::AllLODs;
			// If the merge destination package already exists, it is possible that the mesh is already used in a scene somewhere, or its materials or even just its textures.
			// Static primitives uniform buffers could become invalid after the operation completes and lead to memory corruption. To avoid it, we force a global reregister.
			if (FindObject<UObject>(nullptr, *PackageName))
			{
				FGlobalComponentReregisterContext GlobalReregister;
				MeshUtilities.MergeComponentsToStaticMesh(ComponentsToMerge, World, Setting, nullptr, nullptr, PackageName, AssetsToSync, MergedActorLocation, ScreenAreaSize, true);
			}
			else
			{
				MeshUtilities.MergeComponentsToStaticMesh(ComponentsToMerge, World, Setting, nullptr, nullptr, PackageName, AssetsToSync, MergedActorLocation, ScreenAreaSize, true);
			}
		}
	}

	if (AssetsToSync.Num())
	{
		FAssetRegistryModule& AssetRegistry = FModuleManager::Get().LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
		int32 AssetCount = AssetsToSync.Num();
		for (int32 AssetIndex = 0; AssetIndex < AssetCount; AssetIndex++)
		{
			AssetRegistry.AssetCreated(AssetsToSync[AssetIndex]);
			GEditor->BroadcastObjectReimported(AssetsToSync[AssetIndex]);
		}

		//Also notify the content browser that the new assets exists
		FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
		ContentBrowserModule.Get().SyncBrowserToAssets(AssetsToSync, true);

		// Place new mesh in the world
		if (true) //bReplaceSourceActors
		{
			UStaticMesh* MergedMesh = nullptr;
			if (AssetsToSync.FindItemByClass(&MergedMesh))
			{
				const FScopedTransaction Transaction(LOCTEXT("PlaceMergedActor", "Place Merged Actor"));
				UniqueLevels[0]->Modify();

				UWorld* World = UniqueLevels[0]->OwningWorld;
				FActorSpawnParameters Params;
				Params.OverrideLevel = UniqueLevels[0];
				FRotator MergedActorRotation(ForceInit);

				AStaticMeshActor* MergedActor = World->SpawnActor<AStaticMeshActor>(MergedActorLocation, MergedActorRotation, Params);
				MergedActor->GetStaticMeshComponent()->SetStaticMesh(MergedMesh);
				MergedActor->SetActorLabel(MergedMesh->GetName());
				World->UpdateCullDistanceVolumes(MergedActor, MergedActor->GetStaticMeshComponent());
				GEditor->SelectNone(true, true);
				GEditor->SelectActor(MergedActor, true, true);
				// Remove source actors
				for (AActor* Actor : Actors)
				{
					Actor->Destroy();
				}
			}
		}
	}

	return true;
}
int32 USceneToolHelper::InstancesMergeForWorld(UWorld* World, bool bSelect, bool simpleInstancesMerge)
{
	// Gather a list of original actors of merge
	if (OriginalActorEntries.Num() > 0)
	{
		OriginalActorEntries.Empty();
	}
	int32 undoNum = 0;
	if (!bSelect)
	{
		TArray<AActor*> actors;
		UGameplayStatics::GetAllActorsOfClass(World, AActor::StaticClass(), actors);

		TArray<UPrimitiveComponent*> other;
		TMap<AActor*, TArray<UPrimitiveComponent*>> campusobjs;
		TMap<AActor*, TArray<UPrimitiveComponent*>> buildingobjs;
		TMap<AActor*, TArray<UPrimitiveComponent*>> floorobjs;
		TMap<AActor*, TArray<UPrimitiveComponent*>> roomobjs;

		FName thing = TEXT("Thing");
		FName campus = TEXT("Campus");
		FName building = TEXT("Building");
		FName floor = TEXT("Floor");
		FName room = TEXT("Room");

		for (auto actor : actors)
		{
			AActor* parentObj = actor->GetAttachParentActor();
			TArray<AActor*> attachActors;
			actor->GetAttachedActors(attachActors);
			if (actor->Tags.Contains(thing))
			{
				if(simpleInstancesMerge)
				{
					continue;
				}
				if (actor->GetAttachParentActor()->Tags.Contains(campus))
				{
					campusobjs = AddMergeComponents(campusobjs, attachActors, parentObj, actor);
				}
				else if (actor->GetAttachParentActor()->Tags.Contains(building))
				{
					buildingobjs = AddMergeComponents(buildingobjs, attachActors, parentObj, actor);
				}
				else if (actor->GetAttachParentActor()->Tags.Contains(floor))
				{
					floorobjs = AddMergeComponents(floorobjs, attachActors, parentObj, actor);
				}
				else if (actor->GetAttachParentActor()->Tags.Contains(room))
				{
					roomobjs = AddMergeComponents(roomobjs, attachActors, parentObj, actor);
				}
			}
			else
			{
				//但凡使用了tag的物体都不参与合批
				if (actor->Tags.Num() == 0)
				{
					auto itemstatic = Cast<UStaticMeshComponent>(actor->GetComponentByClass(UStaticMeshComponent::StaticClass()));
					other.Add(itemstatic);
				}
			}
		}

		if (other.Num() > 0)
		{
			undoNum++;
		}
		MergeComponentsToInstances(nullptr, other, World, false, true, true);
		if (!simpleInstancesMerge)
		{
			if (campusobjs.Num() > 0)
			{
				undoNum++;
			}
			for (auto item : campusobjs)
			{
				MergeComponentsToInstances(item.Key, item.Value, World, false, true, true);
			}
			
			if (buildingobjs.Num() > 0)
			{
				undoNum++;
			}
			for (auto item : buildingobjs)
			{
				MergeComponentsToInstances(item.Key, item.Value, World, false, true, true);
			}
			
			if (floorobjs.Num() > 0)
			{
				undoNum++;
			}
			for (auto item : floorobjs)
			{
				MergeComponentsToInstances(item.Key, item.Value, World, false, true, true);
			}
			
			if (roomobjs.Num() > 0)
			{
				undoNum++;
			}
			for (auto item : roomobjs)
			{
				MergeComponentsToInstances(item.Key, item.Value, World, false, true, true);
			}
		}
		return undoNum;
	}
	else
	{
		TArray<UPrimitiveComponent*> ComponentsToMerge;
		USelection* SelectedActors = GEditor->GetSelectedActors();
		for (FSelectionIterator Iter(*SelectedActors); Iter; ++Iter)
		{
			// We only care about actors that are referenced in the world for literals, and also in the same level as this blueprint
			AActor* Actor = Cast<AActor>(*Iter);
			auto itemstatic = Cast<UStaticMeshComponent>(Actor->GetComponentByClass(UStaticMeshComponent::StaticClass()));
			if (itemstatic)
			{
				ComponentsToMerge.Add(itemstatic);
			}
		}
		DefaultMergeComponentsToInstances(ComponentsToMerge, World, true, true);
		return undoNum;
	}
}
void USceneToolHelper::MergeComponentsToInstances(AActor* parent, TArray<UPrimitiveComponent*> ComponentsToMerge, UWorld* World, bool bSelect /*= false*/, bool bActuallyMerge /*= true*/, bool bRemoveOriginal /*= false*/)
{
	ULevel* Level = World->GetCurrentLevel();

	FMeshInstancingSettings InSettings;
	//set InSettings.MeshReplacementMethod
	if (bRemoveOriginal)
	{
		InSettings.MeshReplacementMethod = EMeshInstancingReplacementMethod::RemoveOriginalActors;
	}
	else
	{
		InSettings.MeshReplacementMethod = EMeshInstancingReplacementMethod::KeepOriginalActorsAsEditorOnly;
	}

	auto HasInstanceVertexColors = [](UStaticMeshComponent* StaticMeshComponent)
	{
		for (const FStaticMeshComponentLODInfo& CurrentLODInfo : StaticMeshComponent->LODData)
		{
			if (CurrentLODInfo.OverrideVertexColors != nullptr || CurrentLODInfo.PaintedVertices.Num() > 0)
			{
				return true;
			}
		}

		return false;
	};

	// Gather valid components
	TArray<UStaticMeshComponent*> ValidComponents;
	for (UPrimitiveComponent* ComponentToMerge : ComponentsToMerge)
	{
		if (UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(ComponentToMerge))
		{
			// Dont harvest from 'destination' actors
			if (StaticMeshComponent->GetOwner()->GetClass() != InSettings.ActorClassToUse.Get())
			{
				if (!InSettings.bSkipMeshesWithVertexColors || !HasInstanceVertexColors(StaticMeshComponent))
				{
					ValidComponents.Add(StaticMeshComponent);
				}
			}
		}
	}

	// if(OutResultsText != nullptr)
	// {
	// 	*OutResultsText = LOCTEXT("InstanceMergePredictedResultsNone", "The current settings will not result in any instanced meshes being created");
	// }

	if (ValidComponents.Num() > 0)
	{
		/** Helper struct representing a spawned ISMC */
		struct FComponentEntry
		{
			FComponentEntry(UStaticMeshComponent* InComponent)
			{
				StaticMesh = InComponent->GetStaticMesh();
				InComponent->GetUsedMaterials(Materials);
				bReverseCulling = InComponent->GetComponentTransform().ToMatrixWithScale().Determinant() < 0.0f;
				CollisionProfileName = InComponent->GetCollisionProfileName();
				CollisionEnabled = InComponent->GetCollisionEnabled();
				OriginalComponents.Add(InComponent);
			}

			bool operator==(const FComponentEntry& InOther) const
			{
				return
					StaticMesh == InOther.StaticMesh &&
					Materials == InOther.Materials &&
					bReverseCulling == InOther.bReverseCulling &&
					CollisionProfileName == InOther.CollisionProfileName &&
					CollisionEnabled == InOther.CollisionEnabled;
			}

			UStaticMesh* StaticMesh;

			TArray<UMaterialInterface*> Materials;

			TArray<UStaticMeshComponent*> OriginalComponents;

			FName CollisionProfileName;

			bool bReverseCulling;

			ECollisionEnabled::Type CollisionEnabled;
		};

		// Helper struct representing a spawned ISMC-containing actor
		struct FActorEntry
		{
			FActorEntry(UStaticMeshComponent* InComponent, ULevel* InLevel)
				: MergedActor(nullptr)
			{
				// intersect with HLOD volumes if we have a level
				if (InLevel)
				{
					for (AActor* Actor : InLevel->Actors)
					{
						if (AHierarchicalLODVolume* HierarchicalLODVolume = Cast<AHierarchicalLODVolume>(Actor))
						{
							FBox BoundingBox = InComponent->Bounds.GetBox();
							FBox VolumeBox = HierarchicalLODVolume->GetComponentsBoundingBox(true);

							if (VolumeBox.IsInside(BoundingBox) || (HierarchicalLODVolume->bIncludeOverlappingActors && VolumeBox.Intersect(BoundingBox)))
							{
								HLODVolume = HierarchicalLODVolume;
								break;
							}
						}
					}
				}
			}

			bool operator==(const FActorEntry& InOther) const
			{
				return HLODVolume == InOther.HLODVolume;
			}

			TArray<FString> ActorNames;
			AActor* MergedActor;
			AHierarchicalLODVolume* HLODVolume;
			TArray<FComponentEntry> ComponentEntries;
		};

		// 收集要合并的组件列表
		TArray<FActorEntry> ItemActorEntries;
		for (UStaticMeshComponent* StaticMeshComponent : ValidComponents)
		{
			int32 ActorEntryIndex = ItemActorEntries.AddUnique(FActorEntry(StaticMeshComponent, InSettings.bUseHLODVolumes ? Level : nullptr));
			FActorEntry& ActorEntry = ItemActorEntries[ActorEntryIndex];

			FComponentEntry ComponentEntry(StaticMeshComponent);

			// 获取Actor的UClass
			UClass* ActorClass = StaticMeshComponent->GetOwner()->GetClass();
			// 取得对应的蓝图
			UBlueprint* Blueprint = ActorClass ? Cast<UBlueprint>(ActorClass->ClassGeneratedBy) : nullptr;

			if (Blueprint == nullptr)
			{
				// 检查是否已经存在相同key的组件组
				if (FComponentEntry* ExistingComponentEntry = ActorEntry.ComponentEntries.FindByKey(ComponentEntry))
				{
					if (!ExistingComponentEntry->OriginalComponents.Contains(StaticMeshComponent))
					{
						ExistingComponentEntry->OriginalComponents.Add(StaticMeshComponent);
					}
				}
				else
				{
					ActorEntry.ComponentEntries.Add(ComponentEntry);
				}
			}
		}

		// 收集要合并的角色列表
		TArray<FActorEntry> ActorEntries;

		for (auto ComponentEntry : ItemActorEntries[0].ComponentEntries)
		{
			FActorEntry ActorEntry = FActorEntry(ComponentEntry.OriginalComponents[0], InSettings.bUseHLODVolumes ? Level : nullptr);
			ActorEntry.ComponentEntries.Add(ComponentEntry);
			ActorEntries.Add(ActorEntry);
		}

		// Filter by component count
		for (FActorEntry& ActorEntry : ActorEntries)
		{
			ActorEntry.ComponentEntries = ActorEntry.ComponentEntries.FilterByPredicate([&InSettings](const FComponentEntry& InEntry)
			{
				return InEntry.OriginalComponents.Num() >= InSettings.InstanceReplacementThreshold;
			});
		}

		// Remove any empty actor entries
		ActorEntries.RemoveAll([](const FActorEntry& ActorEntry) { return ActorEntry.ComponentEntries.Num() == 0; });

		int32 TotalComponentCount = 0;
		TArray<AActor*> ActorsToCleanUp;
		for (FActorEntry& ActorEntry : ActorEntries)
		{
			for (const FComponentEntry& ComponentEntry : ActorEntry.ComponentEntries)
			{
				TotalComponentCount++;
				for (UStaticMeshComponent* OriginalComponent : ComponentEntry.OriginalComponents)
				{
					if (AActor* OriginalActor = OriginalComponent->GetOwner())
					{
						ActorsToCleanUp.AddUnique(OriginalActor);
					}
				}
			}
		}

		if (ActorEntries.Num() > 0)
		{
			// if(OutResultsText != nullptr)
			// {
			// 	*OutResultsText = FText::Format(LOCTEXT("InstanceMergePredictedResults", "The current settings will result in {0} instanced static mesh components ({1} actors will be replaced)"), FText::AsNumber(TotalComponentCount), FText::AsNumber(ActorsToCleanUp.Num()));
			// }

			if (bActuallyMerge)
			{
				// Create our actors
				const FScopedTransaction Transaction(LOCTEXT("PlaceInstancedActors", "Place Instanced Actor(s)"));
				Level->Modify();

				FActorSpawnParameters Params;
				Params.OverrideLevel = Level;

				// We now have the set of component data we want to apply
				for (FActorEntry& ActorEntry : ActorEntries)
				{
					ActorEntry.MergedActor = World->SpawnActor<AActor>(InSettings.ActorClassToUse.Get(), Params);

					for (const FComponentEntry& ComponentEntry : ActorEntry.ComponentEntries)
					{
						UInstancedStaticMeshComponent* NewComponent = nullptr;

						NewComponent = (UInstancedStaticMeshComponent*)ActorEntry.MergedActor->FindComponentByClass(InSettings.ISMComponentToUse.Get());

						if (NewComponent && NewComponent->PerInstanceSMData.Num() > 0)
						{
							NewComponent = nullptr;
						}

						if (NewComponent == nullptr)
						{
							NewComponent = NewObject<UInstancedStaticMeshComponent>(ActorEntry.MergedActor, InSettings.ISMComponentToUse.Get());

							if (ActorEntry.MergedActor->GetRootComponent())
							{
								// Attach to root if we already have one
								NewComponent->AttachToComponent(ActorEntry.MergedActor->GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
								// ActorEntry = FActorEntry(ComponentEntry.OriginalComponents[0], InSettings.bUseHLODVolumes ? Level : nullptr);
								// ActorEntry.ComponentEntries = itemActorEntry.ComponentEntries;
								// ActorEntry.MergedActor = World->SpawnActor<AActor>(InSettings.ActorClassToUse.Get(), Params);
							}
							else
							{
								// Make a new root if we dont have a root already
								ActorEntry.MergedActor->SetRootComponent(NewComponent);
							}
							// Take 'instanced' ownership so it persists with this actor
							ActorEntry.MergedActor->RemoveOwnedComponent(NewComponent);
							NewComponent->CreationMethod = EComponentCreationMethod::Instance;
							ActorEntry.MergedActor->AddOwnedComponent(NewComponent);
						}

						NewComponent->SetStaticMesh(ComponentEntry.StaticMesh);
						for (int32 MaterialIndex = 0; MaterialIndex < ComponentEntry.Materials.Num(); ++MaterialIndex)
						{
							NewComponent->SetMaterial(MaterialIndex, ComponentEntry.Materials[MaterialIndex]);
						}
						NewComponent->SetReverseCulling(ComponentEntry.bReverseCulling);
						NewComponent->SetCollisionProfileName(ComponentEntry.CollisionProfileName);
						NewComponent->SetCollisionEnabled(ComponentEntry.CollisionEnabled);
						NewComponent->SetMobility(EComponentMobility::Movable);
						for (UStaticMeshComponent* OriginalComponent : ComponentEntry.OriginalComponents)
						{
							int32 InstanceIndex = NewComponent->AddInstance(OriginalComponent->GetComponentTransform());
							FOriginalActorEntry* OriginalActor = new FOriginalActorEntry(OriginalComponent, ActorEntry.MergedActor, InstanceIndex);
							if (!OriginalActorEntries.Contains(OriginalActor))
							{
								if (parent)
								{
									OriginalActorEntries.Add(OriginalActor);
									ActorEntry.MergedActor->Tags.Add(FName("Actor:" + OriginalActor->DisplayName));
								}
							}
						}
						NewComponent->RegisterComponent();
					}

					World->UpdateCullDistanceVolumes(ActorEntry.MergedActor);
				}

				// Now clean up our original actors
				for (AActor* ActorToCleanUp : ActorsToCleanUp)
				{
					if (InSettings.MeshReplacementMethod == EMeshInstancingReplacementMethod::RemoveOriginalActors)
					{
						ActorToCleanUp->Destroy();
					}
					else if (InSettings.MeshReplacementMethod == EMeshInstancingReplacementMethod::KeepOriginalActorsAsEditorOnly)
					{
						ActorToCleanUp->Modify();
						ActorToCleanUp->bIsEditorOnlyActor = true;
						ActorToCleanUp->SetHidden(true);
						ActorToCleanUp->bHiddenEd = true;
						ActorToCleanUp->SetIsTemporarilyHiddenInEditor(true);
					}
				}

				// pop a toast allowing selection
				auto SelectActorsLambda = [ActorEntries]()
				{
					GEditor->GetSelectedActors()->Modify();
					GEditor->GetSelectedActors()->BeginBatchSelectOperation();
					GEditor->SelectNone(false, true, false);

					for (const FActorEntry& ActorEntry : ActorEntries)
					{
						GEditor->SelectActor(ActorEntry.MergedActor, true, false, true);
					}

					GEditor->GetSelectedActors()->EndBatchSelectOperation();
				};

				FNotificationInfo NotificationInfo(FText::Format(LOCTEXT("CreatedInstancedActorsMessage", "Created {0} Instanced Actor(s)"), FText::AsNumber(ActorEntries.Num())));
				NotificationInfo.Hyperlink = FSimpleDelegate::CreateLambda(SelectActorsLambda);
				NotificationInfo.HyperlinkText = LOCTEXT("SelectActorsHyperlink", "Select Actors");
				NotificationInfo.ExpireDuration = 5.0f;

				FSlateNotificationManager::Get().AddNotification(NotificationInfo);
			}
		}
		if (parent)
		{
			for (auto itemActor : ActorEntries)
			{
				itemActor.MergedActor->SetActorLabel(parent->GetActorLabel() + "__Instance");
				FString Left;
				FString Right;
				Level->GetFullName().Split(TEXT("."), &Left, &Right);
				Right.Split(TEXT(":"), &Left, &Right);
				FName tag("__MapName__:" + Left);
				itemActor.MergedActor->Tags.Add("Thing");
				itemActor.MergedActor->Tags.Add(tag);
				auto actorToWorld = itemActor.MergedActor->GetTransform();
				itemActor.MergedActor->AttachToActor(parent, FAttachmentTransformRules(EAttachmentRule::KeepRelative, false));
				itemActor.MergedActor->SetActorTransform(actorToWorld);
			}
		}
		else
		{
			for (auto itemActor : ActorEntries)
			{
				itemActor.MergedActor->SetActorLabel(itemActor.MergedActor->GetActorLabel() + "__Instance");
			}
		}
	}
}
void USceneToolHelper::DefaultMergeComponentsToInstances(TArray<UPrimitiveComponent*>& ComponentsToMerge, UWorld* World, bool bActuallyMerge /*= true*/, bool bRemoveOriginal /*= false*/)
{
	ULevel* Level = World->GetCurrentLevel();
	
	FMeshInstancingSettings InSettings;
	//set InSettings.MeshReplacementMethod
	if (bRemoveOriginal)
	{
		InSettings.MeshReplacementMethod = EMeshInstancingReplacementMethod::RemoveOriginalActors;
	}
	else
	{
		InSettings.MeshReplacementMethod = EMeshInstancingReplacementMethod::KeepOriginalActorsAsEditorOnly;
	}
	
	auto HasInstanceVertexColors = [](UStaticMeshComponent* StaticMeshComponent)
	{
		for (const FStaticMeshComponentLODInfo& CurrentLODInfo : StaticMeshComponent->LODData)
		{
			if(CurrentLODInfo.OverrideVertexColors != nullptr || CurrentLODInfo.PaintedVertices.Num() > 0)
			{
				return true;
			}
		}

		return false;
	};

	// Gather valid components
	TArray<UStaticMeshComponent*> ValidComponents;
	for(UPrimitiveComponent* ComponentToMerge : ComponentsToMerge)
	{
		if(UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(ComponentToMerge))
		{
			// Dont harvest from 'destination' actors
			if(StaticMeshComponent->GetOwner()->GetClass() != InSettings.ActorClassToUse.Get())
			{
				if( !InSettings.bSkipMeshesWithVertexColors || !HasInstanceVertexColors(StaticMeshComponent))
				{
					ValidComponents.Add(StaticMeshComponent);
				}
			}
		}
	}

	if(ValidComponents.Num() > 0)
	{
		/** Helper struct representing a spawned ISMC */
		struct FComponentEntry
		{
			FComponentEntry(UStaticMeshComponent* InComponent)
			{
				StaticMesh = InComponent->GetStaticMesh();
				InComponent->GetUsedMaterials(Materials);
				bReverseCulling = InComponent->GetComponentTransform().ToMatrixWithScale().Determinant() < 0.0f;
				CollisionProfileName = InComponent->GetCollisionProfileName();
				CollisionEnabled = InComponent->GetCollisionEnabled();
				OriginalComponents.Add(InComponent);
			}

			bool operator==(const FComponentEntry& InOther) const
			{
				return 
					StaticMesh == InOther.StaticMesh &&
					Materials == InOther.Materials &&
					bReverseCulling == InOther.bReverseCulling && 
					CollisionProfileName == InOther.CollisionProfileName &&
					CollisionEnabled == InOther.CollisionEnabled;
			}

			UStaticMesh* StaticMesh;

			TArray<UMaterialInterface*> Materials;

			TArray<UStaticMeshComponent*> OriginalComponents;

			FName CollisionProfileName;

			bool bReverseCulling;

			ECollisionEnabled::Type CollisionEnabled;
		};

		/** Helper struct representing a spawned ISMC-containing actor */
		struct FActorEntry
		{
			FActorEntry(UStaticMeshComponent* InComponent, ULevel* InLevel)
				: MergedActor(nullptr)
			{
				// intersect with HLOD volumes if we have a level
				if(InLevel)
				{
					for (AActor* Actor : InLevel->Actors)
					{
						if (AHierarchicalLODVolume* HierarchicalLODVolume = Cast<AHierarchicalLODVolume>(Actor))
						{
							FBox BoundingBox = InComponent->Bounds.GetBox();
							FBox VolumeBox = HierarchicalLODVolume->GetComponentsBoundingBox(true);

							if (VolumeBox.IsInside(BoundingBox) || (HierarchicalLODVolume->bIncludeOverlappingActors && VolumeBox.Intersect(BoundingBox)))
							{
								HLODVolume = HierarchicalLODVolume;
								break;
							}
						}
					}
				}
			}

			bool operator==(const FActorEntry& InOther) const
			{
				return HLODVolume == InOther.HLODVolume;
			}

			AActor* MergedActor;
			AHierarchicalLODVolume* HLODVolume;
			TArray<FComponentEntry> ComponentEntries;
		};

		// Gather a list of components to merge
		TArray<FActorEntry> ActorEntries;
		for(UStaticMeshComponent* StaticMeshComponent : ValidComponents)
		{
			int32 ActorEntryIndex = ActorEntries.AddUnique(FActorEntry(StaticMeshComponent, InSettings.bUseHLODVolumes ? Level : nullptr));
			FActorEntry& ActorEntry = ActorEntries[ActorEntryIndex];

			FComponentEntry ComponentEntry(StaticMeshComponent);

			if(FComponentEntry* ExistingComponentEntry = ActorEntry.ComponentEntries.FindByKey(ComponentEntry))
			{
				ExistingComponentEntry->OriginalComponents.Add(StaticMeshComponent);
			}
			else
			{
				ActorEntry.ComponentEntries.Add(ComponentEntry);
			}
		}

		// Filter by component count
		for(FActorEntry& ActorEntry : ActorEntries)
		{
			ActorEntry.ComponentEntries = ActorEntry.ComponentEntries.FilterByPredicate([&InSettings](const FComponentEntry& InEntry)
			{
				return InEntry.OriginalComponents.Num() >= InSettings.InstanceReplacementThreshold;
			});
		}

		// Remove any empty actor entries
		ActorEntries.RemoveAll([](const FActorEntry& ActorEntry){ return ActorEntry.ComponentEntries.Num() == 0; });

		int32 TotalComponentCount = 0;
		TArray<AActor*> ActorsToCleanUp;
		for(FActorEntry& ActorEntry : ActorEntries)
		{
			for(const FComponentEntry& ComponentEntry : ActorEntry.ComponentEntries)
			{
				TotalComponentCount++;
				for(UStaticMeshComponent* OriginalComponent : ComponentEntry.OriginalComponents)
				{
					if(AActor* OriginalActor = OriginalComponent->GetOwner())
					{
						ActorsToCleanUp.AddUnique(OriginalActor);
					}
				}
			}
		}

		if(ActorEntries.Num() > 0)
		{
			
			if(bActuallyMerge)
			{
				// Create our actors
				const FScopedTransaction Transaction(LOCTEXT("PlaceInstancedActors", "Place Instanced Actor(s)"));
				Level->Modify();

 				FActorSpawnParameters Params;
 				Params.OverrideLevel = Level;

				// We now have the set of component data we want to apply
				for(FActorEntry& ActorEntry : ActorEntries)
				{
					ActorEntry.MergedActor = World->SpawnActor<AActor>(InSettings.ActorClassToUse.Get(), Params);

					for(const FComponentEntry& ComponentEntry : ActorEntry.ComponentEntries)
					{
						UInstancedStaticMeshComponent* NewComponent = nullptr;

						NewComponent = (UInstancedStaticMeshComponent*)ActorEntry.MergedActor->FindComponentByClass(InSettings.ISMComponentToUse.Get());

						if (NewComponent && NewComponent->PerInstanceSMData.Num() > 0)
						{
							NewComponent = nullptr;
						}

						if (NewComponent == nullptr)
						{
							NewComponent = NewObject<UInstancedStaticMeshComponent>(ActorEntry.MergedActor, InSettings.ISMComponentToUse.Get());
						
							if (ActorEntry.MergedActor->GetRootComponent())
							{
								// Attach to root if we already have one
								NewComponent->AttachToComponent(ActorEntry.MergedActor->GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
							}
							else
							{
								// Make a new root if we dont have a root already
								ActorEntry.MergedActor->SetRootComponent(NewComponent);
							}

							// Take 'instanced' ownership so it persists with this actor
							ActorEntry.MergedActor->RemoveOwnedComponent(NewComponent);
							NewComponent->CreationMethod = EComponentCreationMethod::Instance;
							ActorEntry.MergedActor->AddOwnedComponent(NewComponent);

						}

						NewComponent->SetStaticMesh(ComponentEntry.StaticMesh);
						for(int32 MaterialIndex = 0; MaterialIndex < ComponentEntry.Materials.Num(); ++MaterialIndex)
						{
							NewComponent->SetMaterial(MaterialIndex, ComponentEntry.Materials[MaterialIndex]);
						}
						NewComponent->SetReverseCulling(ComponentEntry.bReverseCulling);
						NewComponent->SetCollisionProfileName(ComponentEntry.CollisionProfileName);
						NewComponent->SetCollisionEnabled(ComponentEntry.CollisionEnabled);
						NewComponent->SetMobility(EComponentMobility::Static);
						for(UStaticMeshComponent* OriginalComponent : ComponentEntry.OriginalComponents)
						{
							NewComponent->AddInstance(OriginalComponent->GetComponentTransform());
						}

						NewComponent->RegisterComponent();
					}

					World->UpdateCullDistanceVolumes(ActorEntry.MergedActor);
				}

				// Now clean up our original actors
				for(AActor* ActorToCleanUp : ActorsToCleanUp)
				{
					if(InSettings.MeshReplacementMethod == EMeshInstancingReplacementMethod::RemoveOriginalActors)
					{
						ActorToCleanUp->Destroy();
					}
					else if(InSettings.MeshReplacementMethod == EMeshInstancingReplacementMethod::KeepOriginalActorsAsEditorOnly)
					{
						ActorToCleanUp->Modify();
						ActorToCleanUp->bIsEditorOnlyActor = true;
						ActorToCleanUp->SetHidden(true);
						ActorToCleanUp->bHiddenEd = true;
						ActorToCleanUp->SetIsTemporarilyHiddenInEditor(true);
					}
				}

				// pop a toast allowing selection
				auto SelectActorsLambda = [ActorEntries]()
				{ 
					GEditor->GetSelectedActors()->Modify();
					GEditor->GetSelectedActors()->BeginBatchSelectOperation();
					GEditor->SelectNone(false, true, false);

					for(const FActorEntry& ActorEntry : ActorEntries)
					{
						GEditor->SelectActor(ActorEntry.MergedActor, true, false, true);
					}

					GEditor->GetSelectedActors()->EndBatchSelectOperation();
				};

				FNotificationInfo NotificationInfo(FText::Format(LOCTEXT("CreatedInstancedActorsMessage", "Created {0} Instanced Actor(s)"), FText::AsNumber(ActorEntries.Num())));
				NotificationInfo.Hyperlink = FSimpleDelegate::CreateLambda(SelectActorsLambda);
				NotificationInfo.HyperlinkText = LOCTEXT("SelectActorsHyperlink", "Select Actors");
				NotificationInfo.ExpireDuration = 5.0f;

				FSlateNotificationManager::Get().AddNotification(NotificationInfo);
			}
		}
	}
}

void USceneToolHelper::PrepPakControl()
{
	TArray<FString> maps;
	IFileManager::Get().FindFilesRecursive(maps, *FPaths::ProjectContentDir(), TEXT("*.umap"), true, false, false);
	// 获取当前关卡的UWorld指针
	UWorld* curWorld = GEditor->GetEditorWorldContext().World();
	if (curWorld != nullptr)
	{
		// 获取关卡的长包名(Long Package Name)
		FString LongPackageName = curWorld->GetOutermost()->GetName();
		FString FileSystemPath;
		FPackageName::TryConvertLongPackageNameToFilename(LongPackageName, FileSystemPath,TEXT(".umap"));
		// 查找具有给定值的元素的索引
		int32 ElementIndex = maps.IndexOfByPredicate([&](const FString& item) {
			return item == FileSystemPath;
		});
		// 如果找到了元素，将其移动到数组的末尾
		if (ElementIndex != INDEX_NONE)
		{
			maps.RemoveAtSwap(ElementIndex);
			maps.Add(FileSystemPath);
		}
	}
	TArray<FString> FileToOpen;
	TArray<FString> FileToChange;
	// IPlatformFile& PlatformFileSystem = IPlatformFile::GetPlatformPhysical();
	for (auto fileToOpen : maps)
	{
		if (fileToOpen.Contains("Content/__InstanceMap/"))
		{
			IFileManager::Get().Delete(*fileToOpen, true, false);
			// PlatformFileSystem.DeleteFile(*fileToOpen);
		}
	}

	const bool bLoadAsTemplate = false;
	const bool bShowProgress = true;
	FString config = "{";
	int32 index = 0;
	FString path = FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir());
	for (auto itemMap : maps)
	{
		bool isOpen = FEditorFileUtils::LoadMap(itemMap, bLoadAsTemplate, bShowProgress); //加载复制过后的场景
		if (isOpen)
		{
			UWorld* World = GEditor->GetEditorWorldContext().World();
			InstancesMergeForWorld(World, false,true);              // 合批
			config = SaveOriginalActorEntries(World, path, config); // 写入数据
			FEditorFileUtils::SaveCurrentLevel();                                      // 保存场景

			index++;
			if (index < FileToOpen.Num())
			{
				config += ",";
			}
		}
	}
	config += "}";

	FString pathDrectory = UPakToolHelper::InitPakPath(false);
	FString pathDrectoryPIE = UPakToolHelper::InitPakPath(true);
	FString filePath = pathDrectory + "MapEntries.json";
	FString filePath1 = pathDrectoryPIE + "MapEntries.json";
	if (!FPlatformFileManager::Get().Get().GetPlatformFile().DirectoryExists(*pathDrectory))
	{
		FPlatformFileManager::Get().Get().GetPlatformFile().CreateDirectoryTree(*pathDrectory);
	}
	if (!FPlatformFileManager::Get().Get().GetPlatformFile().DirectoryExists(*pathDrectoryPIE))
	{
		FPlatformFileManager::Get().Get().GetPlatformFile().CreateDirectoryTree(*pathDrectoryPIE);
	}
	FFileHelper::SaveStringToFile(config, *filePath);
	FFileHelper::SaveStringToFile(config, *filePath1);
	UE_LOG(LogTemp, Log, TEXT("MergeComponentsToInstances Successful!"));
}
UE4-构建更好的静态网格体
DuoHeReShui的博客
07-18 6117
在“构件更好的三维网格体这部分”，我们会讨论包括系统单位、三角面数量、材质ID、枢轴点，我们会学习什么是光照贴图，然后介绍如何创建光照贴图。我们将学习碰撞网格体的创建和使用，细节层级或 LOD，最后介绍如何限制过度绘制。 1.系统单位 无论你使用哪种数字内容创建软件（DCC），创建对象前你需要先确定系统单位。本文中，我将使用 3d Studio Max，不过我涉及到的原理适用于所有数字内容创建软件。首先，我们需要确保将系统单位设为厘米，因为厘米是虚幻引擎4默认的测量单位。在虚幻引擎4中，一虚幻单位等于一厘米
ue4 模板类实例化_UE4 ISM(实例化静态网格体)理解
weixin_36340200的博客
01-12 4221
知乎文章可能格式有错乱，如果发现格式问题，请看原文吧。环境： Unreal Engine 4.25.2此文介绍了ISM即UInstancedStaticMeshComponent的使用，分析了编辑和渲染代码。A component that efficiently renders multiple instances of the same StaticMesh.TL;DRISM的所有实例一起，无...
ue4 unreal Instanced Static Mesh Component 实例化静态网格体组件 的用法及意义
ljason1993的博客
12-28 9896
注意这是个组件 ​​ 这个组件的意义 本来在建模软件里面就有这个功能 用来应对大量，同样网格，同样材质，不同几何信息（位置 旋转 缩放）的网格 比如场景里面的垃圾桶 电线杆 路灯等几百上千的东西 我试过一两万挺轻松的... 比较骚的操作是可以更新几何信息，比如会上下乱动，随便缩放等这种，不过同样的，总数就会下降（保证不卡的情况下） ----------------------------------------------------------------------------...
ue4 合并静态网格体（合并Actor）
专栏
09-18 1791
ue4 合并静态网格体（合并Actor）。
UE4 合并静态网格体
ChaoChao66666的博客
07-19 5380
如下图，如何将世界大纲中的所有静态网格体（StaticMeshActor）合并为一个模型？3.在菜单栏点击窗口-》开发者工具-》合并Actor。5.选择合并后模型的存放地点，并为模型命名，点击保存。1.在世界大纲中找到所有存在的静态网格体。4.在弹出的窗口中点击合并Actor。2.Ctrl+A全选。......
【ue4】【新手入门】|静态网格模型碰撞设置和合并Actor（合并静态网格体）
m0_63501513的博客
07-20 2943
上一期学到把构建好的房子模型变成一个静态网格体（也是一个模型）但是静态网格体是没有碰撞的 所以要给这个模型设置碰撞。
【UE4 C++】根据指定路径生成静态网格体
ChaoChao66666的博客
07-12 1929
​在上一篇博客中（【UE C++】蓝图调用C++函数），我们用C++创建了一个蓝图函数库，本篇文章在这个蓝图函数库基础上增加一个方法，该方法只需输入一个文件目录路径，就可在场景中生成该目录下得所有静态网格体。（如果不想写C++的话，可以用这篇文章的方法：UE4 | BP | 使用蓝图获取Uasset资源_ue4 蓝图加载uasset资产）
如何在UE5中区分Nanite网格体和静态网格体：深入指南与代码实现
最新发布
10-05
本文将详细介绍如何在UE5中区分Nanite网格体和静态网格体，包括它们的工作原理、优势以及如何在项目中实现这些技术。 通过本文的介绍，你应该对如何在UE5中区分Nanite网格体和静态网格体有了全面的了解。Nanite技术...
基于UE4.21，通过顶点与面索引DataTable，借助ProceduralMeshComponent批量绘制静态网格体资源
10-26
matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接...
UE4HeightMapGenerator:从高度图纹理生成网格
05-06
UE4HeightMapGenerator 示例如何使用UProceduralMeshComponent从高度图纹理生成网格。 您可以定义： 从中生成的纹理（应该是灰度和幂二） 材质分配给生成的网格 生成的网格尺寸 多边形大小 优化类型： None, //...
ue4 改变枢轴位置_UE4-构建更好的静态网格体
weixin_39999222的博客
11-22 1810
在本文中，我们会讨论包括系统单位、三角面数量、材质ID、枢轴点，我们会学习什么是光照贴图，然后介绍如何创建光照贴图。我们将学习碰撞网格体的创建和使用，细节层级或 LOD，最后介绍如何限制过度绘制。1.系统单位无论你使用哪种数字内容创建软件（DCC），创建对象前你需要先确定系统单位。本文中，我将使用 3d Studio Max，不过我涉及到的原理适用于所有数字内容创建软件。首先，我们需要确保将系统单...
Unreal 5 实现使用GPU Instancing批量渲染相同的物体
现在学习也不晚
06-30 2859
之前做unity的时候，专门研究了使用GPU进行批量相同的物体渲染，现在转ue以后，发现UE也有相同的功能。接下来讲解一下，在ue里面如何实现通过GPU进行实例化渲染。
【游戏编程扯淡精粹】UE5 蓝图
游戏编程扯淡精粹
10-20 7975
最近新学蓝图编程。。还没看蓝图VM代码，有些点不保证准确本文主要是从使用角度，分析你为什么需要学习蓝图，蓝图适合做什么，不适合做什么最后 Bonus，跟一下 Blueprint Pipeline，梳理一下蓝图的知识结构。
UE4引用替换：两个同类型的蓝图对象，怎么合并成只用其中一个（eg：把别人的gameinstance和你的gameinstance合并，全部用你的ganmeinstance）
weixin_43704737的博客
07-21 1938
举个例子： 用插件时，你的工程和插件的game instance 不是同一个，但是换起来又麻烦，怎么合成一个 解决：这里以 struct 类作为介绍对象 增加测试对象 然后delete掉不要的就ok了
UE4 C++ 小项目汇总
肘子的博客
03-11 583
**项目实现：**一个旋转上下的立方体 项目地址：传送门 **操作流程：**创建一个c++c++c++类，以ActorActorActor为父类，然后编写代码，.h.h.h中可以写点属性，材质，.cpp.cpp.cpp中实现构造函数和Tick()Tick()Tick()函数 函数精华： FloatingActor.hFloatingActor.hFloatingActor.h //声明的是 StaticMeshComponent，它将担当对象的视觉表示。 public: UPROPERTY(Visible
【UE4】【笔记】5、UE4学习笔记 LOD与合并静态网格体
Triumph_Dynamic08
05-18 6973
UE4官方视频学习笔记——LOD与合并静态网格体 大纲如下： ​​ UE4LOD自动创建工具 LOD自动创建工具 选择一个静态网格体，打开静态网格编辑器，并在细节面板中找到LOD Settings分组： 该分组中有一个属性“LOD Group”： 该属性中预存了许多类型的分组，比如Foliage、HighDetail等，当你选择其中一个的时候，UE4将会读取BaseEngine.ini中的配置数据，并按照预设好的配置为该静态网格体生成指定规格的LOD数据： 手动修改LOD参数 假如我们应用了Larg
UE4 静态网格体碰撞 Collision Prims:0
weixin_44009226的博客
08-06 2209
问题： 问题出现过程： 制作贪吃蛇案例，食物是自己建的，蛇头碰到食物后出现检测不到的问题。 食物是用笔刷创建几何体(一个椭圆球减去下半部分) 组合得到的形状 （形状见下面图） 然后创建了静态网络物体 一个蓝图类里添加这个静态网格体 如图 出现碰撞模拟检测 检测不到这个蓝图的问题 而新建的测试蓝图，点击绿色添加组件， 添加的 Cube则可以被检测到 对比发现 笔刷创建那个 静态网格体显示 Collision Prims:0 如图：图片是改好的，之前 Collision Prims:0 且为黄色，感觉是这
UE4 中 为StaticMesh添加贴合物体的碰撞
伟的专栏
01-13 1万+
因为在导入FBX文件到UE4中时自动生成 的Collision并不是很理想。   所以导入FBX时将 Auto Generate Collision去除勾选。这里引擎不会为你生成碰撞信息， 运行时就会出现人物穿墙无限坠落 找到导入到Content中的StaticMesh 双击打开 打开后在Details面板中找到Static MeshSettings分
P4Merge的使用
weixin_30360497的博客
08-03 1775
(官网： https://www.perforce.com/products/helix-core-apps/merge-diff-tool-p4merge 可以作为一个stand alone app) 原来如此方便：https://www.bbsmax.com/A/amd08Enkdg/ good! P4Merge文档： https://www.perforce.com/manu...
UE4 FBX静态网格物体通道
热门推荐
痞子龙3D编程
09-02 1万+
On this page: 概述一般设置 支点三角化UV 贴图坐标创建法线贴图材质碰撞 警告和注意事项 顶点颜色 导出网格物体导入网格物体静态网格物体LOD LOD设置导出LOD导入LOD... 概述 FBX导入通道中的静态网格物体支持使得将网格物体从3D应用程序中导入到虚幻引擎4中变得更加容易简单。这时不仅会导入网格物体，而且也会导入在3D应用程序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dawn·张

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值