Add support Unreal Engine 4.25.

Author: Deema35

.gitignore

@@ -56,4 +56,9 @@ Saved/*
 Build/*
 
 # Cache files for the editor to use
-DerivedDataCache/*
+DerivedDataCache/*
+
+#Plugin directory
+Plugins/LevelGenPlugin/Intermediate/*
+Plugins/LevelGenPlugin/Binaries/*
+!Plugins/LevelGenPlugin/Binaries/Win64/*.dll

Binaries/Win64/LevelGenEditor.target

@@ -1,5 +1,5 @@
 {
-	"BuildId": "4212847",
+	"BuildId": "13144385",
 	"Modules": 
 	{
 		"LevelGen": "UE4Editor-LevelGen.dll"

Binaries/Win64/UE4Editor-LevelGen.dll

@@ -1,6 +1,6 @@
 {
 	"FileVersion": 3,
-	"EngineAssociation": "4.20",
+	"EngineAssociation": "4.25",
 	"Category": "",
 	"Description": "",
 	"Modules": [

Binaries/Win64/UE4Editor.modules

@@ -1,5 +1,5 @@
 {
-	"BuildId": "4212847",
+	"BuildId": "13144385",
 	"Modules": 
 	{
 		"LevelGenPluginEditor": "UE4Editor-LevelGenPluginEditor.dll",

Config/DefaultEditor.ini

@@ -7,6 +7,7 @@
 #include "NotificationManager.h"
 #include "SButton.h"
 #include "STextBlock.h"
+#include "AssetEditorManager.h"
 #include "Rooms/RoomStorage.h"
 #include "ActorStorage_AssetEditor.h"
 #include "ActorContainer.h"

Content/Environment/Materials/SIFI_Windows_02/M_SIFI_Windows_02.uasset

@@ -588,7 +588,7 @@ void FDataFillerBildingDisposer::FillData(FVector2D Start, FVector2D End)
 					std::shuffle(Bildings.begin(), Bildings.end(), LevelGenerator.GetRandomGenerator().GetGenerator());
 					for (auto CurrentBilding : Bildings)
 					{
-						bool On90Deg = LevelGenerator.GetRandomGenerator().GetRandomNumber(0, 1);
+						bool On90Deg = (bool)LevelGenerator.GetRandomGenerator().GetRandomNumber(0, 1);
 
 
 						if (CurrentBilding->IsPlaceFit(FVector2D(i, j), On90Deg ? EYawTurn::HalfPi : EYawTurn::Zero, DataStorage))

Content/Environment/Materials/SIFI_Windows_02/RoomInteriorNoWindow.uasset

@@ -118,7 +118,7 @@ FCarTrackGraphBase* FCarTrackLink::GetNextTrack(int LayerNum) const
 
 FCarTrackNode::FCarTrackNode(EHoverCarTrackDirection _Direction, std::pair<FVector, FVector> FirstPoint, std::pair<FVector, FVector> SecondPoint, const FLevelGenRoadBase* _TrackRoadOwner,
 	const FLevelGeneratorSettings& LevelSettings, const FDataStorage& DataStorage)
-	: Direction(_Direction), FCarTrackGraphBase(LevelSettings, DataStorage), TrackRoadOwner(_TrackRoadOwner)
+	: FCarTrackGraphBase(LevelSettings, DataStorage), Direction(_Direction), TrackRoadOwner(_TrackRoadOwner)
 {
 
 	switch (Direction)

LevelGen.uproject

@@ -38,7 +38,7 @@ class FCarTrackGraphBase
 public:
 
 	FCarTrackGraphBase(const FLevelGeneratorSettings& _LevelSettings, const FDataStorage& _DataStorage) :
-		LevelSettings(_LevelSettings), RandomGenerator(time(0)), DataStorage(_DataStorage) {}
+		LevelSettings(_LevelSettings),  DataStorage(_DataStorage), RandomGenerator(time(0)) {}
 
 	virtual ~FCarTrackGraphBase() {}
 

Plugins/LevelGenPlugin/Binaries/Win64/UE4Editor-LevelGenPluginEditor.dll

@@ -51,7 +51,7 @@ FLevelCellBase* ELevelCellTypeCreate(ELevelCellType Type, FLevelCellData& CellDa
 //FLevelCellData
 //*******************************************************
 
-FLevelCellData::FLevelCellData(const FLevelGeneratorSettings& Settings, FVector2D _CellCoordinate, const FDataStorage& DataStorage) : LevelSettings(Settings), CellCoordinate(_CellCoordinate)
+FLevelCellData::FLevelCellData(const FLevelGeneratorSettings& Settings, FVector2D _CellCoordinate, const FDataStorage& DataStorage) : CellCoordinate(_CellCoordinate), LevelSettings(Settings)
 {
 	Floors.resize(Settings.FloorNum, FLevelFloorData(DataStorage));
 

Plugins/LevelGenPlugin/Binaries/Win64/UE4Editor-LevelGenPluginRuntime.dll

@@ -77,17 +77,17 @@ void FLevelGenBildingZoneBase::CreateGraphLayers()
 	}
 }
 
-void FLevelGenBildingZoneBase::CreateTowers(const FLevelGeneratorSettings& LevelSettings, const ALevelGenerator& LevelGenerator, FDataStorage& DataStorage)
+void FLevelGenBildingZoneBase::CreateTowers(const FLevelGeneratorSettings& LevelSettings_loc, const ALevelGenerator& LevelGenerator_loc, FDataStorage& DataStorage_loc)
 {
-	FVector2D NumTowers(RoundNumber(Size.X / LevelSettings.TowerFrequency, ERoundType::Up), RoundNumber(Size.Y / LevelSettings.TowerFrequency, ERoundType::Up));
+	FVector2D NumTowers(RoundNumber(Size.X / LevelSettings_loc.TowerFrequency, ERoundType::Up), RoundNumber(Size.Y / LevelSettings_loc.TowerFrequency, ERoundType::Up));
 
 	std::vector<const FLevelTower*> TowersFromStorage;
-	LevelGenerator.GetTowerStorage()->GetTowers(TowersFromStorage);
+	LevelGenerator_loc.GetTowerStorage()->GetTowers(TowersFromStorage);
 
 
-	std::shuffle(TowersFromStorage.begin(), TowersFromStorage.end(), LevelGenerator.GetRandomGenerator().GetGenerator());
+	std::shuffle(TowersFromStorage.begin(), TowersFromStorage.end(), LevelGenerator_loc.GetRandomGenerator().GetGenerator());
 
-	UObjectsDisposer TowerDisposer(std::make_pair(Coordinate, Coordinate + Size), LevelGenerator.GetRandomGenerator().GetGenerator(), LevelSettings);
+	UObjectsDisposer TowerDisposer(std::make_pair(Coordinate, Coordinate + Size), LevelGenerator_loc.GetRandomGenerator().GetGenerator(), LevelSettings_loc);
 
 	if (NumTowers.X < 0 || NumTowers.Y < 0) throw;
 
@@ -104,20 +104,20 @@ void FLevelGenBildingZoneBase::CreateTowers(const FLevelGeneratorSettings& Level
 			{
 				auto Predicate = [&](FVector Coordinate)
 				{
-					return TowersFromStorage[k]->IsPlaceFit(FVector2D(Coordinate), EYawTurn::Zero, DataStorage);
+					return TowersFromStorage[k]->IsPlaceFit(FVector2D(Coordinate), EYawTurn::Zero, DataStorage_loc);
 				};
 
 				FVector2D ToverCoordinate(0,0);
 
-				int CellOffsetX = LevelGenerator.GetRandomGenerator().GetRandomNumber(-LevelSettings.TowerFrequency / 2, LevelSettings.TowerFrequency / 2);
-				int CellOffsetY = LevelGenerator.GetRandomGenerator().GetRandomNumber(-LevelSettings.TowerFrequency / 2, LevelSettings.TowerFrequency / 2);
+				int CellOffsetX = LevelGenerator_loc.GetRandomGenerator().GetRandomNumber(-LevelSettings_loc.TowerFrequency / 2, LevelSettings_loc.TowerFrequency / 2);
+				int CellOffsetY = LevelGenerator_loc.GetRandomGenerator().GetRandomNumber(-LevelSettings_loc.TowerFrequency / 2, LevelSettings_loc.TowerFrequency / 2);
 
 
-				FVector2D SearchStartCoordinate = Coordinate + FVector2D(i * LevelSettings.TowerFrequency + CellOffsetX, j * LevelSettings.TowerFrequency + CellOffsetY);
+				FVector2D SearchStartCoordinate = Coordinate + FVector2D(i * LevelSettings_loc.TowerFrequency + CellOffsetX, j * LevelSettings_loc.TowerFrequency + CellOffsetY);
 
 				if (TowerDisposer.GetLocation(ToverCoordinate, SearchStartCoordinate, 0, TowersFromStorage[k]->Size, Predicate))
 				{
-					BildingTowers[i][j] = std::shared_ptr<FPlacedLevelTower>(new FPlacedLevelTower(TowersFromStorage[k], ToverCoordinate, EYawTurn::Zero, DataStorage, LevelSettings));
+					BildingTowers[i][j] = std::shared_ptr<FPlacedLevelTower>(new FPlacedLevelTower(TowersFromStorage[k], ToverCoordinate, EYawTurn::Zero, DataStorage_loc, LevelSettings_loc));
 					break;
 				}
 			}
@@ -1730,12 +1730,12 @@ void FLevelGenBildingZoneBase::EdgeCut()
 
 
 
-bool FLevelGenBildingZoneBase::CheckCell(FVector2D Coordinate)
+bool FLevelGenBildingZoneBase::CheckCell(FVector2D Coordinate_loc)
 {
 
-	if (DataStorage.LevelMap.IsCellExist(Coordinate) && DataStorage.LevelMap.GetCell(Coordinate)->CellInst && DataStorage.LevelMap.GetCell(Coordinate)->CellInst->CanEdgeCut())
+	if (DataStorage.LevelMap.IsCellExist(Coordinate_loc) && DataStorage.LevelMap.GetCell(Coordinate_loc)->CellInst && DataStorage.LevelMap.GetCell(Coordinate_loc)->CellInst->CanEdgeCut())
 	{
-		for (auto CellFloorIT = DataStorage.LevelMap.GetCell(Coordinate)->Floors.begin(); CellFloorIT != DataStorage.LevelMap.GetCell(Coordinate)->Floors.end(); CellFloorIT++)
+		for (auto CellFloorIT = DataStorage.LevelMap.GetCell(Coordinate_loc)->Floors.begin(); CellFloorIT != DataStorage.LevelMap.GetCell(Coordinate_loc)->Floors.end(); CellFloorIT++)
 		{
 			if (CellFloorIT->PlasedRoom)
 			{
@@ -1750,12 +1750,12 @@ bool FLevelGenBildingZoneBase::CheckCell(FVector2D Coordinate)
 	return false;
 }
 
-bool FLevelGenBildingZoneBase::CheckCellFloors(FVector2D Coordinate)
+bool FLevelGenBildingZoneBase::CheckCellFloors(FVector2D Coordinate_loc)
 {
 
-	if (DataStorage.LevelMap.IsCellExist(Coordinate))
+	if (DataStorage.LevelMap.IsCellExist(Coordinate_loc))
 	{
-		for (auto CellFloorIT = DataStorage.LevelMap.GetCell(Coordinate)->Floors.begin(); CellFloorIT != DataStorage.LevelMap.GetCell(Coordinate)->Floors.end(); CellFloorIT++)
+		for (auto CellFloorIT = DataStorage.LevelMap.GetCell(Coordinate_loc)->Floors.begin(); CellFloorIT != DataStorage.LevelMap.GetCell(Coordinate_loc)->Floors.end(); CellFloorIT++)
 		{
 			if (CellFloorIT->PlasedRoom)
 			{
@@ -1770,11 +1770,11 @@ bool FLevelGenBildingZoneBase::CheckCellFloors(FVector2D Coordinate)
 	return false;
 }
 
-void FLevelGenBildingZoneBase::ReplaceCell(FVector2D Coordinate)
+void FLevelGenBildingZoneBase::ReplaceCell(FVector2D Coordinate_loc)
 {
-	std::shared_ptr<FLevelCellBase> LastCell = std::move(DataStorage.LevelMap.GetCell(Coordinate)->CellInst);
+	std::shared_ptr<FLevelCellBase> LastCell = std::move(DataStorage.LevelMap.GetCell(Coordinate_loc)->CellInst);
 	FLevelCellBilding* Bilding = static_cast<FLevelCellBilding*>(LastCell.get());
-	DataStorage.LevelMap.GetCell(Coordinate)->CellInst = std::shared_ptr<FLevelCellBase>(new FLevelCellThroughCell(*Bilding));
+	DataStorage.LevelMap.GetCell(Coordinate_loc)->CellInst = std::shared_ptr<FLevelCellBase>(new FLevelCellThroughCell(*Bilding));
 }
 
 
@@ -1912,7 +1912,7 @@ void FLevelGenBildingZone::CreateProceduralFigure()
 		GetSenterCoordinate().Y * LevelSettings.CellSize, 0), &LevelSettings.RoadGroundMaterial);
 }
 
-void FLevelGenBildingZone::ConnectBildingToLevelCells(FDataStorage& DataStorage)
+void FLevelGenBildingZone::ConnectBildingToLevelCells(FDataStorage& DataStorage_loc)
 {
 	for (int i = 0; i < (int)EDirection::end; i++)
 	{
@@ -1922,30 +1922,30 @@ void FLevelGenBildingZone::ConnectBildingToLevelCells(FDataStorage& DataStorage)
 
 		for (auto CurrentCoordinate = WallCellsCoordinate.begin(); CurrentCoordinate != WallCellsCoordinate.end(); CurrentCoordinate++)
 		{
-			DataStorage.LevelMap.GetCell(*CurrentCoordinate)->LinkedBildingZone = this;
+			DataStorage_loc.LevelMap.GetCell(*CurrentCoordinate)->LinkedBildingZone = this;
 		}
 	}
 
 	for (int i = Coordinate.X; i < Coordinate.X + Size.X; i++)
 	{
 		for (int j = Coordinate.Y; j < Coordinate.Y + Size.Y; j++)
 		{
-			if (!DataStorage.LevelMap.GetCell(i, j)->CellInst)
+			if (!DataStorage_loc.LevelMap.GetCell(i, j)->CellInst)
 			{
-				DataStorage.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Bilding, *DataStorage.LevelMap.GetCell(i, j)));
+				DataStorage_loc.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Bilding, *DataStorage_loc.LevelMap.GetCell(i, j)));
 
 			}
 			else
 			{
-				if (DataStorage.LevelMap.GetCell(i, j)->CellInst->GetCellType() != ELevelCellType::Tower)
+				if (DataStorage_loc.LevelMap.GetCell(i, j)->CellInst->GetCellType() != ELevelCellType::Tower)
 				{
-					DataStorage.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Bilding, *DataStorage.LevelMap.GetCell(i, j)));
+					DataStorage_loc.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Bilding, *DataStorage_loc.LevelMap.GetCell(i, j)));
 					UE_LOG(LogTemp, Warning, TEXT("ConnectBildingToLevelCells bad cell type %s"),
-						*GetEnumValueAsString<ELevelCellType>("ELevelCellType", DataStorage.LevelMap.GetCell(i, j)->CellInst->GetCellType()));
+						*GetEnumValueAsString<ELevelCellType>("ELevelCellType", DataStorage_loc.LevelMap.GetCell(i, j)->CellInst->GetCellType()));
 
 				}
 			}
-			DataStorage.LevelMap.GetCell(i, j)->LinkedBildingZone = this;
+			DataStorage_loc.LevelMap.GetCell(i, j)->LinkedBildingZone = this;
 		}
 	}
 
@@ -2032,7 +2032,7 @@ void FLevelGenBildingZoneTower::CreateTowerFasedeWallSegment(FVector WallCoordin
 		GetSenterCoordinate().Y * LevelSettings.CellSize, 0), &LevelSettings.BildingWallMaterial);
 }
 
-void FLevelGenBildingZoneTower::ConnectBildingToLevelCells(FDataStorage& DataStorage)
+void FLevelGenBildingZoneTower::ConnectBildingToLevelCells(FDataStorage& DataStorage_loc)
 {
 	for (int i = 0; i < (int)EDirection::end; i++)
 	{
@@ -2042,16 +2042,16 @@ void FLevelGenBildingZoneTower::ConnectBildingToLevelCells(FDataStorage& DataSto
 
 		for (auto CurrentCoordinate = WallCellsCoordinate.begin(); CurrentCoordinate != WallCellsCoordinate.end(); CurrentCoordinate++)
 		{
-			DataStorage.LevelMap.GetCell(*CurrentCoordinate)->LinkedBildingZone = this;
+			DataStorage_loc.LevelMap.GetCell(*CurrentCoordinate)->LinkedBildingZone = this;
 		}
 	}
 
 	for (int i = Coordinate.X; i < Coordinate.X + Size.X; i++)
 	{
 		for (int j = Coordinate.Y; j < Coordinate.Y + Size.Y; j++)
 		{
-			DataStorage.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Tower, *DataStorage.LevelMap.GetCell(i, j)));
-			DataStorage.LevelMap.GetCell(i, j)->LinkedBildingZone = this;
+			DataStorage_loc.LevelMap.GetCell(i, j)->CellInst = std::shared_ptr<FLevelCellBase>(ELevelCellTypeCreate(ELevelCellType::Tower, *DataStorage_loc.LevelMap.GetCell(i, j)));
+			DataStorage_loc.LevelMap.GetCell(i, j)->LinkedBildingZone = this;
 		}
 	}
 

Plugins/LevelGenPlugin/Binaries/Win64/UE4Editor.modules

@@ -214,7 +214,7 @@ class UObjectsDisposer
 public:
 
 	UObjectsDisposer(std::pair<FVector2D, FVector2D> _SearchAreaRange, std::mt19937& _RandomGenerator, const FLevelGeneratorSettings& _LevelSettings) :
-		SearchAreaRange(_SearchAreaRange),  RandomGenerator(_RandomGenerator), LevelSettings(_LevelSettings)
+		LevelSettings(_LevelSettings), SearchAreaRange(_SearchAreaRange), RandomGenerator(_RandomGenerator)
 	{
 		if (SearchAreaRange.first.X > SearchAreaRange.second.X || SearchAreaRange.first.Y > SearchAreaRange.second.Y) throw FString("Bad search area");
 	}

Plugins/LevelGenPlugin/Source/LevelGenPluginEditor/ActorContainerDetailPanelCostamization.cpp

@@ -12,7 +12,7 @@ public LevelGenPluginRuntime(ReadOnlyTargetRules ROTargetRules) : base(ROTargetR
 
         PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "ProceduralMeshComponent" });
 
-		PrivateDependencyModuleNames.AddRange(new string[] { "RHI", "RenderCore", "ShaderCore" });
+		PrivateDependencyModuleNames.AddRange(new string[] { "RHI", "RenderCore"});
 
 		// Uncomment if you are using Slate UI
 		// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });

Plugins/LevelGenPlugin/Source/LevelGenPluginRuntime/DataFillers.cpp

@@ -116,7 +116,7 @@ void FLevelGenProceduralMeshSceneProxy::GetDynamicMeshElements(const TArray<cons
 	if (bWireframe)
 	{
 		WireframeMaterialInstance = new FColoredMaterialRenderProxy(
-			GEngine->WireframeMaterial ? GEngine->WireframeMaterial->GetRenderProxy(IsSelected()) : NULL,
+			GEngine->WireframeMaterial ? GEngine->WireframeMaterial->GetRenderProxy() : NULL,
 			FLinearColor(0, 0.5f, 1.f)
 		);
 
@@ -128,7 +128,7 @@ void FLevelGenProceduralMeshSceneProxy::GetDynamicMeshElements(const TArray<cons
 	{
 		if (Sections[i] && Sections[i]->bSectionVisible)
 		{
-			FMaterialRenderProxy* MaterialProxy = bWireframe ? WireframeMaterialInstance : Sections[i]->Material->GetRenderProxy(IsSelected());
+			FMaterialRenderProxy* MaterialProxy = bWireframe ? WireframeMaterialInstance : Sections[i]->Material->GetRenderProxy();
 
 			// For each view..
 			for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
@@ -143,7 +143,7 @@ void FLevelGenProceduralMeshSceneProxy::GetDynamicMeshElements(const TArray<cons
 					Mesh.bWireframe = bWireframe;
 					Mesh.VertexFactory = &Sections[i]->VertexFactory;
 					Mesh.MaterialRenderProxy = MaterialProxy;
-					BatchElement.PrimitiveUniformBuffer = CreatePrimitiveUniformBufferImmediate(GetLocalToWorld(), GetBounds(), GetLocalBounds(), true, UseEditorDepthTest());
+					BatchElement.PrimitiveUniformBuffer = nullptr;
 					BatchElement.FirstIndex = 0;
 					BatchElement.NumPrimitives = Sections[i]->IndexBuffer.Indices.Num() / 3;
 					BatchElement.MinVertexIndex = 0;
@@ -168,7 +168,7 @@ void FLevelGenProceduralMeshSceneProxy::GetDynamicMeshElements(const TArray<cons
 			if (ViewFamily.EngineShowFlags.Collision && IsCollisionEnabled() && BodySetup->GetCollisionTraceFlag() != ECollisionTraceFlag::CTF_UseComplexAsSimple)
 			{
 				FTransform GeomTransform(GetLocalToWorld());
-				BodySetup->AggGeom.GetAggGeom(GeomTransform, GetSelectionColor(FColor(157, 149, 223, 255), IsSelected(), IsHovered()).ToFColor(true), NULL, false, false, UseEditorDepthTest(), ViewIndex, Collector);
+				BodySetup->AggGeom.GetAggGeom(GeomTransform, GetSelectionColor(FColor(157, 149, 223, 255), IsSelected(), IsHovered()).ToFColor(true), NULL, false, false, DrawsVelocity(), ViewIndex, Collector);
 			}
 
 			// Render bounds