Maptilemanager.cpp

gistfile1.txt

// Fill out your copyright notice in the Description page of Project Settings.

#include "SWP_MapTileManager.h"
#include "Components/StaticMeshComponent.h"
#include "Engine/StaticMesh.h"
#include "UObject/ConstructorHelpers.h"
#include "SWP_WorldPlayerPawn.h"
#include "Runtime/Renderer/Public/PrimitiveSceneInfo.h"

#include "Runtime/ImageWriteQueue/Public/ImageWriteBlueprintLibrary.h"
#include "Runtime/Engine/Public/HighResScreenshot.h"
#include "Runtime/ImageWriteQueue/Public/ImageWriteTask.h"
#include "Runtime/ImageWriteQueue/Public/ImageWriteQueue.h"
#include "Runtime/ImageWriteQueue/Public/ImagePixelData.h"
#include "HttpService.h"
#include "Runtime/AssetRegistry/Public/AssetRegistryModule.h"
#include "Runtime/ImageWrapper/Public/IImageWrapper.h"
#include "Runtime/ImageWrapper/Public/IImageWrapperModule.h"
#include "SWP_SaveManager.h"
#include "Kismet/GameplayStatics.h"
#include "SmartWorldPro.h"

class ASWP_WorldPlayerPawn;
class UImageWriteBlueprintLibrary;
class FImageWriteTask;
class IImageWriteQueue;


// Sets default values
ASWP_MapTileManager::ASWP_MapTileManager()
{
	struct FConstructorStatics
	{
		ConstructorHelpers::FObjectFinderOptional<UStaticMesh> PlaneMesh;
		FConstructorStatics() : PlaneMesh(TEXT("StaticMesh'/Engine/BasicShapes/Plane.Plane'"))
		{

		}
	};

	static FConstructorStatics ConstructorStatics;


 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	

	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	ManagerRoot = CreateDefaultSubobject<USceneComponent>(TEXT("ManagerRoot"));
	ManagerRoot = RootComponent;

	plane00 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane00"));
	plane00->SetupAttachment(ManagerRoot);
	plane00->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane00->SetVisibility(false);

	plane01 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane01"));
	plane01->SetupAttachment(ManagerRoot);
	plane01->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane01->SetVisibility(false);

	plane02 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane02"));
	plane02->SetupAttachment(ManagerRoot);
	plane02->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane02->SetVisibility(false);

	plane03 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane03"));
	plane03->SetupAttachment(ManagerRoot);
	plane03->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane03->SetVisibility(false);

	plane04 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane04"));
	plane04->SetupAttachment(ManagerRoot);
	plane04->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane04->SetVisibility(false);

	plane10 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane10"));
	plane10->SetupAttachment(ManagerRoot);
	plane10->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane10->SetVisibility(false);

	plane11 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane11"));
	plane11->SetupAttachment(ManagerRoot);
	plane11->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane11->SetVisibility(false);

	plane12 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane12"));
	plane12->SetupAttachment(ManagerRoot);
	plane12->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane12->SetVisibility(false);

	plane13 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane13"));
	plane13->SetupAttachment(ManagerRoot);
	plane13->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane13->SetVisibility(false);

	plane14 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane14"));
	plane14->SetupAttachment(ManagerRoot);
	plane14->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane14->SetVisibility(false);

	plane20 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane20"));
	plane20->SetupAttachment(ManagerRoot);
	plane20->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane20->SetVisibility(false);

	plane21 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane21"));
	plane21->SetupAttachment(ManagerRoot);
	plane21->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane21->SetVisibility(false);

	plane22 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane22"));
	plane22->SetupAttachment(ManagerRoot);
	plane22->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane22->SetVisibility(false);

	plane23 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane23"));
	plane23->SetupAttachment(ManagerRoot);
	plane23->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane23->SetVisibility(false);

	plane24 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane24"));
	plane24->SetupAttachment(ManagerRoot);
	plane24->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane24->SetVisibility(false);

	plane30 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane30"));
	plane30->SetupAttachment(ManagerRoot);
	plane30->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane30->SetVisibility(false);

	plane31 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane31"));
	plane31->SetupAttachment(ManagerRoot);
	plane31->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane31->SetVisibility(false);

	plane32 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane32"));
	plane32->SetupAttachment(ManagerRoot);
	plane32->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane32->SetVisibility(false);

	plane33 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane33"));
	plane33->SetupAttachment(ManagerRoot);
	plane33->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane33->SetVisibility(false);

	plane34 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane34"));
	plane34->SetupAttachment(ManagerRoot);
	plane34->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane34->SetVisibility(false);

	plane40 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane40"));
	plane40->SetupAttachment(ManagerRoot);
	plane40->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane40->SetVisibility(false);

	plane41 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane41"));
	plane41->SetupAttachment(ManagerRoot);
	plane41->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane41->SetVisibility(false);

	plane42 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane42"));
	plane42->SetupAttachment(ManagerRoot);
	plane42->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane42->SetVisibility(false);

	plane43 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane43"));
	plane43->SetupAttachment(ManagerRoot);
	plane43->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane43->SetVisibility(false);

	plane44 = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Plane44"));
	plane44->SetupAttachment(ManagerRoot);
	plane44->SetStaticMesh(ConstructorStatics.PlaneMesh.Get());
	plane44->SetVisibility(false);

	static ConstructorHelpers::FObjectFinder<UMaterial> EngineTestMat(TEXT("Material'/Engine/EngineDebugMaterials/DebugMeshMaterial.DebugMeshMaterial'"));
	static ConstructorHelpers::FObjectFinder<UMaterial> TileTestMat(TEXT("Material'/Game/SWPContent/Materials/Mat_Tile.Mat_Tile'"));
	static ConstructorHelpers::FObjectFinder<UMaterialInstance>TileTestMatInst(TEXT("MaterialInstanceConstant'/Game/SWPContent/Materials/Mat_Tile_Inst1.Mat_Tile_Inst1'"));

	if (EngineTestMat.Succeeded() && DEBUG_TILECOMPONENTS == 1)
	{
		mStaticMesh = EngineTestMat.Object;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Earth Material Found"));
	}

	if (TileTestMatInst.Succeeded())
	{
		mTileInst = TileTestMatInst.Object;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Tile Material  Found"));
	}

	
	mapLat = 28.507878f;
	mapLon = 77.085348f;
	rows = 5;
	columns = 5;
	zoomLevel = 10;
	qualityLevel = 2;
	SaveTimer = 5.f;
	currentSaveTimer = 0.f;
	cacheTileMap.Reserve(120);


	if (DEBUG_TILECOMPONENTS == 1)
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Grid Rows: %s Units  and Column: %s Units respectively"), *FString::FromInt(rows), *FString::FromInt(columns));
		UE_LOG(LogSmartWorldPro, Warning, TEXT("ZoomLevel Value: %s Units  and QualityLevel: %s Units respectively"), *FString::FromInt(zoomLevel), *FString::FromInt(qualityLevel));
		UE_LOG(LogSmartWorldPro, Warning, TEXT("No Default Location Set. Loading Hard Coded Initial Location"));
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Map Latitude : %f and Longitude : %f respectively"), mapLat, mapLon);
	}


}

void ASWP_MapTileManager::PostInitializeComponents()
{
	Super::PostInitializeComponents();

	planes.Add(plane00);
	planes.Add(plane01);
	planes.Add(plane02);
	planes.Add(plane03);
	planes.Add(plane04);

	planes.Add(plane10);
	planes.Add(plane11);
	planes.Add(plane12);
	planes.Add(plane13);
	planes.Add(plane14);

	planes.Add(plane20);
	planes.Add(plane21);
	planes.Add(plane22);
	planes.Add(plane23);
	planes.Add(plane24);
	
	planes.Add(plane30);
	planes.Add(plane31);
	planes.Add(plane32);
	planes.Add(plane33);
	planes.Add(plane34);
	
	
	planes.Add(plane40);
	planes.Add(plane41);
	planes.Add(plane42);
	planes.Add(plane43);
	planes.Add(plane44);

	this->Tags.Add(MapActorTag);

	//float xbounds = plane00->Bounds.BoxExtent.X;
	//float ybounds = plane00->Bounds.BoxExtent.Y;

	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane X bounds %f") , xbounds);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane Y bounds %f"), ybounds);
	//

	//FVector pos = FVector(-4*xbounds, 0, xbounds);
	//pos = FVector(0, 0, 0);
	//
	//plane00->SetRelativeLocation(pos);
	//plane00->SetVisibility(true);
	//
	//mInstance = UMaterialInstanceDynamic::Create(mStaticMesh, this);
	////mInstance = UMaterialInstanceDynamic::Create(plane00->GetStaticMesh()->GetMaterial(0), this);
	//mInstance->SetVectorParameterValue("Color", FLinearColor::MakeRandomColor());
	//plane00->SetMaterial(0, mInstance);
	//pos = FVector(-0.5f*xbounds, 1.5f* ybounds, 0);
	////plane00->SetRelativeLocation(pos, false, nullptr, ETeleportType::None);
	////plane00->SetRelativeRotation(FRotator(90,0,0),false,nullptr,ETeleportType::None);
	//plane00->SetVisibility(true);

	//mInstance = UMaterialInstanceDynamic::Create(mStaticMesh, this);
	//mInstance->SetVectorParameterValue("Color", FLinearColor::MakeRandomColor());
	//ReferencePlane->SetMaterial(0, mInstance);
	//ReferencePlane->SetRelativeScale3D(FVector(10, 10, 10));
	//ReferencePlane->SetRelativeLocation(FVector(0, 0, 0), false, nullptr, ETeleportType::None);
	//
	//for (int i = 0;i<planes.Num();i++)
	//{
	//	planes[i]->SetRelativeRotation(FRotator(0, 90, 0), false, nullptr, ETeleportType::None);
	//	//planes[i]->SetVisibility(true);
	//	mInstance = UMaterialInstanceDynamic::Create(mTileInst, this);
	//	mInstance->SetVectorParameterValue("Color", FLinearColor::MakeRandomColor());
	//	planes[i]->SetMaterial(0, mInstance);
	//}

}

// Called when the game starts or when spawned
void ASWP_MapTileManager::BeginPlay()
{
	Super::BeginPlay();

	//Init Save Game Object
	InstantiateSaveGameObject();

	/*Get HUD Ref pointer*/
	HUDRef = Cast<AASWP_HUD>(GetWorld()->GetFirstPlayerController()->GetHUD());

	/*Set the Value of the Actor to Origin*/ //SetActorLocation(FVector(650, -400, 450), false, nullptr, ETeleportType::None);
	SetActorLocation(FVector(0,0, 0), false, nullptr, ETeleportType::None);
	
	/*Calculate the Center Tile ID Based on Zoom Level and MapLat And MapLon*/
	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	
	/*Generate Tile ID for all grid elements*/
	GenerateTileIDForGridElements(centerTileIDStruct);
	
	/*Create the Grid with the mentioned Rows and Colums*/
	CreateMapGrid(rows, columns);

	/*Create Web Request based on Tile Data calculated for each tile*/
	CreateWebRequestForTiles();

	//FVector2D newVEc = LatLonToMeters(28.507878, 77.085348);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Center Tile in Meters is X: %f , Y : %f "), newVEc.X,newVEc.Y);

	/*Rearrange the tile components based on the Mercater Projection Coordinates*/
	RearrangeGridElements(mapLat, mapLon, tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY);

	

	//tileViewTimerDelegate = FTimerDelegate::CreateUObject(this, &ASWP_MapTileManager::CheckTileVisibleTimer);
//	GetWorldTimerManager().SetTimer(tileViewTimerHandle,this, &ASWP_MapTileManager::CheckTileVisibleTimer, 0.5f, true);
	
}

void ASWP_MapTileManager::CreateWebRequestForTiles()
{
	//Request for Plane00
	FString str1;
	str1 = FString::FromInt(tileStructureMap[plane00]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane00]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane00]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane00(tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"),*str1);
	}
	else
	{
		//FString ThePath = FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		FString ThePath = str1;
		LoadSavedTexturePlane00(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane01
	str1 = FString::FromInt(tileStructureMap[plane01]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane01]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane01]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane01(tileStructureMap[plane01]->ZoomLevel, tileStructureMap[plane01]->TileX, tileStructureMap[plane01]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane01(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane02
	str1 = FString::FromInt(tileStructureMap[plane02]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane02]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane02]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane02(tileStructureMap[plane02]->ZoomLevel, tileStructureMap[plane02]->TileX, tileStructureMap[plane02]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane02(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane03
	str1 = FString::FromInt(tileStructureMap[plane03]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane03]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane03]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane03(tileStructureMap[plane03]->ZoomLevel, tileStructureMap[plane03]->TileX, tileStructureMap[plane03]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane03(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane04
	str1 = FString::FromInt(tileStructureMap[plane04]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane04]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane04]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane04(tileStructureMap[plane04]->ZoomLevel, tileStructureMap[plane04]->TileX, tileStructureMap[plane04]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane04(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	//Request for Plane10
	str1 = FString::FromInt(tileStructureMap[plane10]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane10]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane10]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane10(tileStructureMap[plane10]->ZoomLevel, tileStructureMap[plane10]->TileX, tileStructureMap[plane10]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane10(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane11
	str1 = FString::FromInt(tileStructureMap[plane11]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane11]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane11]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane11(tileStructureMap[plane11]->ZoomLevel, tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane11(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane12
	str1 = FString::FromInt(tileStructureMap[plane12]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane12]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane12]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane12(tileStructureMap[plane12]->ZoomLevel, tileStructureMap[plane12]->TileX, tileStructureMap[plane12]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane12(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane13
	str1 = FString::FromInt(tileStructureMap[plane13]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane13]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane13]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane13(tileStructureMap[plane13]->ZoomLevel, tileStructureMap[plane13]->TileX, tileStructureMap[plane13]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane13(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane14
	str1 = FString::FromInt(tileStructureMap[plane14]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane14]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane14]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane14(tileStructureMap[plane14]->ZoomLevel, tileStructureMap[plane14]->TileX, tileStructureMap[plane14]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane14(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	//Request for Plane20
	str1 = FString::FromInt(tileStructureMap[plane20]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane20]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane20]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane20(tileStructureMap[plane20]->ZoomLevel, tileStructureMap[plane20]->TileX, tileStructureMap[plane20]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane20(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane21
	str1 = FString::FromInt(tileStructureMap[plane21]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane21]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane21]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane21(tileStructureMap[plane21]->ZoomLevel, tileStructureMap[plane21]->TileX, tileStructureMap[plane21]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane21(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}
	
	////Request for Plane22
	str1 = FString::FromInt(tileStructureMap[plane22]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane22]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane22]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane22(tileStructureMap[plane22]->ZoomLevel, tileStructureMap[plane22]->TileX, tileStructureMap[plane22]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane22(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane23
	str1 = FString::FromInt(tileStructureMap[plane23]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane23]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane23]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane23(tileStructureMap[plane23]->ZoomLevel, tileStructureMap[plane23]->TileX, tileStructureMap[plane23]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane23(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane24
	str1 = FString::FromInt(tileStructureMap[plane24]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane24]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane24]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane24(tileStructureMap[plane24]->ZoomLevel, tileStructureMap[plane24]->TileX, tileStructureMap[plane24]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane24(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	//Request for Plane30
	str1 = FString::FromInt(tileStructureMap[plane30]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane30]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane30]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane30(tileStructureMap[plane30]->ZoomLevel, tileStructureMap[plane30]->TileX, tileStructureMap[plane30]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane30(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane31
	str1 = FString::FromInt(tileStructureMap[plane31]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane31]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane31]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane31(tileStructureMap[plane31]->ZoomLevel, tileStructureMap[plane31]->TileX, tileStructureMap[plane31]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane31(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane32
	str1 = FString::FromInt(tileStructureMap[plane32]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane32]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane32]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane32(tileStructureMap[plane32]->ZoomLevel, tileStructureMap[plane32]->TileX, tileStructureMap[plane32]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane32(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane33
	str1 = FString::FromInt(tileStructureMap[plane33]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane33]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane33]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane33(tileStructureMap[plane33]->ZoomLevel, tileStructureMap[plane33]->TileX, tileStructureMap[plane33]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane33(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane34
	str1 = FString::FromInt(tileStructureMap[plane34]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane34]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane34]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane34(tileStructureMap[plane34]->ZoomLevel, tileStructureMap[plane34]->TileX, tileStructureMap[plane34]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane34(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}


	//Request for Plane40
	str1 = FString::FromInt(tileStructureMap[plane40]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane40]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane40]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane40(tileStructureMap[plane40]->ZoomLevel, tileStructureMap[plane40]->TileX, tileStructureMap[plane40]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane40(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane41
	str1 = FString::FromInt(tileStructureMap[plane41]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane41]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane41]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane41(tileStructureMap[plane41]->ZoomLevel, tileStructureMap[plane41]->TileX, tileStructureMap[plane41]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane41(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane42
	str1 = FString::FromInt(tileStructureMap[plane42]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane42]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane42]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane42(tileStructureMap[plane42]->ZoomLevel, tileStructureMap[plane42]->TileX, tileStructureMap[plane42]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane42(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane43
	str1 = FString::FromInt(tileStructureMap[plane43]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane43]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane43]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane43(tileStructureMap[plane43]->ZoomLevel, tileStructureMap[plane43]->TileX, tileStructureMap[plane43]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane43(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}

	////Request for Plane44
	str1 = FString::FromInt(tileStructureMap[plane44]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane44]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane44]->ZoomLevel) + TEXT("Z");
	if (!FindTileMapInDatabase(str1))
	{
		CreateWebRequestPlane44(tileStructureMap[plane44]->ZoomLevel, tileStructureMap[plane44]->TileX, tileStructureMap[plane44]->TileY, qualityLevel);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File not found. Create HTTP Web Request for %s"), *str1);
	}
	else
	{
		FString ThePath = str1;// FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + str1;
		LoadSavedTexturePlane44(ThePath);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Map File Found. Loading from database"));
	}
}

void ASWP_MapTileManager::CreateMapGrid(int r, int c)
{
	blocklength = 100.0f;
	int planeIndex = 0;
	float xPos = 0;
	float yPos = 0;

	//this->SetActorRotation(FRotator(180, 0, 0), ETeleportType::None);
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			xPos = i * blocklength;
			yPos = j * blocklength;
			planes[planeIndex]->SetRelativeLocation(FVector(-xPos, yPos, 0));
			mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		//	mInstance = UMaterialInstanceDynamic::Create(plane00->GetStaticMesh()->GetMaterial(0), this);
			//mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::MakeRandomColor());
			planes[planeIndex]->SetMaterial(0, mTileInstDyn);
			planes[planeIndex]->SetVisibility(true);
			planes[planeIndex]->SetRelativeRotation(FRotator(0, 90, 0), false, nullptr, ETeleportType::None);
			planeIndex++;
		}
	}
}

FTileIDStruct ASWP_MapTileManager::CalculateTileIDForCenterGridElement(float latitude, float longitude, int zoomLvl)
{

	FTileIDStruct tileIDStruct;
	int32 x = 0;
	int32 y = 0;

	x = (int32)FMath::FloorToFloat((longitude + 180.0f) / 360.f * FMath::Pow(2.0, zoomLvl));
	//y = FMath::FloorToInt((1-FMath::Log2(FMath::Tan(latitude*PI/180.f)+ 1.f/FMath::Cos(latitude * PI/180)/)
	y = (int32)FMath::FloorToFloat((1.0 - FMath::Loge(FMath::Tan(latitude * PI / 180.0) + 1.0 / FMath::Cos(latitude * PI / 180.0)) / PI) / 2.0 * FMath::Pow(2.0, zoomLvl));
	tileIDStruct.TileX = x;
	tileIDStruct.TileY = y;
	tileIDStruct.ZoomLevel = zoomLvl;



	FString TileXStr = FString::FromInt(x);
	FString TileYStr = FString::FromInt(y);
	FString ZoomStr = FString::FromInt(zoomLvl);

	if(DEBUG_TILEINITIALIZE == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Center Tile Structure: TileX:%s  TileY:%s  ZoomLevel:%s "), *TileXStr, *TileYStr, *ZoomStr);

	return tileIDStruct;
}

void ASWP_MapTileManager::GenerateTileIDForGridElements(FTileIDStruct idInfo)
{
	plane00Struct->TileX = idInfo.TileX - 2;
	plane00Struct->TileY = idInfo.TileY - 2;
	plane00Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[0], plane00Struct);
	tileName00 = FString::FromInt(plane00Struct->ZoomLevel) +
									TEXT(",") + 
								FString::FromInt(plane00Struct->TileX) + 
									TEXT(",") + 
									FString::FromInt(plane00Struct->TileY);
	//planes[0]->Rename(compName00,nullptr,0);
//	UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane00 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, tileStructureMap[plane00]->ZoomLevel);

	plane01Struct->TileX = idInfo.TileX - 2;
	plane01Struct->TileY = idInfo.TileY -1;
	plane01Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[1], plane01Struct);
	tileName01 = FString::FromInt(plane01Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane01Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane01Struct->TileY);
	//planes[1]->Rename(compName01, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane01 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane01]->TileX, tileStructureMap[plane01]->TileY, tileStructureMap[plane01]->ZoomLevel);

	plane02Struct->TileX = idInfo.TileX - 2;
	plane02Struct->TileY = idInfo.TileY;
	plane02Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[2], plane02Struct);
	tileName02 = FString::FromInt(plane02Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane02Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane02Struct->TileY);
	//planes[2]->Rename(compName02, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane02 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane02]->TileX, tileStructureMap[plane02]->TileY, tileStructureMap[plane02]->ZoomLevel);

	//tileName03 = TEXT("");
	plane03Struct->TileX = idInfo.TileX - 2;
	plane03Struct->TileY = idInfo.TileY + 1;
	plane03Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[3], plane03Struct);
	tileName03 = FString::FromInt(plane03Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane03Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane03Struct->TileY);
	//const TCHAR* compName02 = *tileName02;
	//planes[2]->Rename(compName02, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane02 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane02]->TileX, tileStructureMap[plane02]->TileY, tileStructureMap[plane02]->ZoomLevel);


	plane04Struct->TileX = idInfo.TileX - 2;
	plane04Struct->TileY = idInfo.TileY + 2;
	plane04Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[4], plane04Struct);
	tileName04 = FString::FromInt(plane04Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane04Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane04Struct->TileY);


	plane10Struct->TileX = idInfo.TileX - 1;
	plane10Struct->TileY = idInfo.TileY - 2;
	plane10Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[5], plane10Struct);
	tileName10 = FString::FromInt(plane10Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane10Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane10Struct->TileY);

	
	plane11Struct->TileX = idInfo.TileX - 1;
	plane11Struct->TileY = idInfo.TileY - 1;
	plane11Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[6], plane11Struct);
	tileName11 = FString::FromInt(plane11Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane11Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane11Struct->TileY);
	
	//planes[4]->Rename(compName11, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane11 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane11].TileX, tileStructureMap[plane11].TileY, tileStructureMap[plane11].ZoomLevel);


	plane12Struct->TileX = idInfo.TileX - 1;
	plane12Struct->TileY = idInfo.TileY;
	plane12Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[7], plane12Struct);
	tileName12 = FString::FromInt(plane12Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane12Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane12Struct->TileY);
	
	//planes[5]->Rename(compName12, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane12 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane12].TileX, tileStructureMap[plane12].TileY, tileStructureMap[plane12].ZoomLevel);

	plane13Struct->TileX = idInfo.TileX - 1;
	plane13Struct->TileY = idInfo.TileY + 1;
	plane13Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[8], plane13Struct);
	tileName13 = FString::FromInt(plane13Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane13Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane13Struct->TileY);


	plane14Struct->TileX = idInfo.TileX - 1;
	plane14Struct->TileY = idInfo.TileY + 2;
	plane14Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[9], plane14Struct);
	tileName14 = FString::FromInt(plane14Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane14Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane14Struct->TileY);
	

	plane20Struct->TileX = idInfo.TileX;
	plane20Struct->TileY = idInfo.TileY - 2;
	plane20Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[10], plane20Struct);
	tileName20 = FString::FromInt(plane20Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane20Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane20Struct->TileY);


	plane21Struct->TileX = idInfo.TileX;
	plane21Struct->TileY = idInfo.TileY - 1;
	plane21Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[11], plane21Struct);
	tileName21 = FString::FromInt(plane21Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane21Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane21Struct->TileY);
	
	plane22Struct->TileX = idInfo.TileX;
	plane22Struct->TileY = idInfo.TileY;
	plane22Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[12], plane22Struct);
	tileName22 = FString::FromInt(plane22Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane22Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane22Struct->TileY);


	plane23Struct->TileX = idInfo.TileX;
	plane23Struct->TileY = idInfo.TileY + 1;
	plane23Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[13], plane23Struct);
	tileName23 = FString::FromInt(plane23Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane23Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane23Struct->TileY);
	//planes[7]->Rename(compName21, nullptr, 0);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Plane21 Stats: Tile Data X %s  | Tile Data Y: %s | Tile Data Zoom: %s"), tileStructureMap[plane21].TileX, tileStructureMap[plane21].TileY, tileStructureMap[plane21].ZoomLevel);


	plane24Struct->TileX = idInfo.TileX;
	plane24Struct->TileY = idInfo.TileY + 2;
	plane24Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[14], plane24Struct);
	tileName24 = FString::FromInt(plane24Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane24Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane24Struct->TileY);
	

	plane30Struct->TileX = idInfo.TileX + 1;
	plane30Struct->TileY = idInfo.TileY - 2;
	plane30Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[15], plane30Struct);
	tileName30 = FString::FromInt(plane30Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane30Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane30Struct->TileY);



	plane31Struct->TileX = idInfo.TileX + 1;
	plane31Struct->TileY = idInfo.TileY - 1;
	plane31Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[16], plane31Struct);
	tileName31 = FString::FromInt(plane31Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane31Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane31Struct->TileY);


	plane32Struct->TileX = idInfo.TileX + 1;
	plane32Struct->TileY = idInfo.TileY;
	plane32Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[17], plane32Struct);
	tileName32 = FString::FromInt(plane32Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane32Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane32Struct->TileY);


	plane33Struct->TileX = idInfo.TileX + 1;
	plane33Struct->TileY = idInfo.TileY + 1;
	plane33Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[18], plane33Struct);
	tileName33 = FString::FromInt(plane33Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane33Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane33Struct->TileY);



	plane34Struct->TileX = idInfo.TileX + 1;
	plane34Struct->TileY = idInfo.TileY + 2;
	plane34Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[19], plane34Struct);
	tileName34 = FString::FromInt(plane34Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane34Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane34Struct->TileY);



	plane40Struct->TileX = idInfo.TileX + 2;
	plane40Struct->TileY = idInfo.TileY - 2;
	plane40Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[20], plane40Struct);
	tileName40 = FString::FromInt(plane40Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane40Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane40Struct->TileY);



	plane41Struct->TileX = idInfo.TileX + 2;
	plane41Struct->TileY = idInfo.TileY - 1;
	plane41Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[21], plane41Struct);
	tileName41 = FString::FromInt(plane41Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane41Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane41Struct->TileY);


	plane42Struct->TileX = idInfo.TileX + 2;
	plane42Struct->TileY = idInfo.TileY;
	plane42Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[22], plane42Struct);
	tileName42 = FString::FromInt(plane42Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane42Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane42Struct->TileY);


	plane43Struct->TileX = idInfo.TileX + 2;
	plane43Struct->TileY = idInfo.TileY + 1;
	plane43Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[23], plane43Struct);
	tileName43 = FString::FromInt(plane43Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane43Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane43Struct->TileY);


	plane44Struct->TileX = idInfo.TileX + 2;
	plane44Struct->TileY = idInfo.TileY + 2;
	plane44Struct->ZoomLevel = idInfo.ZoomLevel;
	tileStructureMap.Add(planes[24], plane44Struct);
	tileName44 = FString::FromInt(plane44Struct->ZoomLevel) +
		TEXT(",") +
		FString::FromInt(plane44Struct->TileX) +
		TEXT(",") +
		FString::FromInt(plane44Struct->TileY);


	
}

/*
double ASWP_MapTileManager::TileYtoNWLatitude(int y, int zoom)
{
	auto n = FMath::Pow(2.0, zoom);
	auto lat_rad = FMath::Atan(FMath::Sinh(PI * (1 - 2 * y / n)));
	auto lat_deg = lat_rad * 180.0 / PI;
	return lat_deg;
}

double ASWP_MapTileManager::TileXtoNWLongitude(int x, int zoom)
{
	auto n = FMath::Pow(2.0, zoom);
	auto lon_deg = x / n * 360.0 - 180.0;
	return lon_deg;
}

FDirectionBounds ASWP_MapTileManager::TileIDToBounds(int x, int y, int zoom)
{
	FDirectionBounds fbounds = FDirectionBounds(FVector2D::ZeroVector, FVector2D::ZeroVector);
	auto sw = FVector2D(TileYtoNWLatitude(y, zoom), TileXtoNWLongitude(x + 1, zoom));
	auto ne = FVector2D(TileYtoNWLatitude(y + 1, zoom), TileXtoNWLongitude(x, zoom));
	fbounds.SouthWest = sw;
	fbounds.NorthEast = ne;
	return fbounds;
}

FVector2D ASWP_MapTileManager::TileIDToCenterLatitudeLongitude(int x, int y, int zoom)
{
	FDirectionBounds bb = TileIDToBounds(x, y, zoom);
	FVector2D center = FVector2D::ZeroVector;
	return center;
}
*/

// Called every frame
void ASWP_MapTileManager::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	if (bCheckSaveTimer)
	{
		currentSaveTimer -= DeltaTime;
		if (currentSaveTimer < 0)
		{
			bCheckSaveTimer = false;

			if (SaveTileData())
			{
				UE_LOG(LogSaveGameManager, Warning, TEXT("Save Data True"));
			}
			currentSaveTimer = 0;
		}
	}

	if (HUDRef != nullptr)
	{
		HUDRef->DebugStringValue = FString::FromInt(zoomLevel) + TEXT(" ZoomLevel");
	}

	//CheckTileVisibleTimer();

}

void ASWP_MapTileManager::GetTileIDsBasedOnZoomLevel(int zoomL)
{
	/*Calculate Important Variables which need to be calculated at every zoomlevel*/
	zoomLevel = zoomL;

	/*Get the Map Center Lat and Long in 2D Vector Form*/
	MapCenterLatLong = FVector2D(mapLat, mapLon);

	/*Get the reference Rectangle of whole grid*/
	ReferenceTileRect = TileBounds(FVector2D(tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY), zoomLevel);
	
	/*Update the center mercartor constant based on the new map Latitude and Longitude*/
	CenterMerc = LatLonToMeters(mapLat, mapLon);

	UE_LOG(LogSmartWorldPro, Warning, TEXT("Zooming Started: Latitude: %d  Longitude: %d"), mapLat, mapLon);


	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	GenerateTileIDForGridElements(centerTileIDStruct);
	CreateWebRequestForTiles();

	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	GenerateTileIDForGridElements(centerTileIDStruct);

	
	RearrangeGridElements(mapLat, mapLon, tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY);
	FVector Position = FVector(plane11->GetComponentLocation().X, plane11->GetComponentLocation().Y, 200);
	ResetPawnPosition(Position);
}

void ASWP_MapTileManager::GetTileIDsBasedOnZoomLevel(int zoomL, FVector2D& CenterLatLong)
{
	/*Calculate Important Variables which need to be calculated at every zoomlevel*/
	zoomLevel = zoomL;

	mapLat = CenterLatLong.X;
	mapLon = CenterLatLong.Y;

	/*Get the Map Center Lat and Long in 2D Vector Form*/
	MapCenterLatLong = FVector2D(mapLat, mapLon);

	/*Get the reference Rectangle of whole grid*/
	ReferenceTileRect = TileBounds(FVector2D(tileStructureMap[plane22]->TileX, tileStructureMap[plane22]->TileY), zoomLevel);

	/*Update the center mercartor constant based on the new map Latitude and Longitude*/
	CenterMerc = LatLonToMeters(mapLat, mapLon);

	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	GenerateTileIDForGridElements(centerTileIDStruct);
	CreateWebRequestForTiles();

	
	
	/*centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	GenerateTileIDForGridElements(centerTileIDStruct);*/

	RearrangeGridElements(mapLat, mapLon, tileStructureMap[plane22]->TileX, tileStructureMap[plane22]->TileY);
	FVector Position = FVector(plane11->GetComponentLocation().X, plane11->GetComponentLocation().Y, 200);
	ResetPawnPosition(Position);
}
/*
void ASWP_MapTileManager::LoadData()
{
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request..."));
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(TEXT("https://dev.virtualearth.net/REST/V1/Imagery/Map/Road/42.6564%2C-73.7638/13?mapSize=500,500&format=png&key=AkifuYNww2KS1pe9K37LkekrCDdfWiYMbfiF9djdY5x2oghRu2PjLxmVGAu_8ZMo"));
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadDataFinished);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::OnLoadDataFinished(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("/Game/SWPContent/Materials/Textures/TestImage.TestImage");
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit"));
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager,0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}
		
		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTex = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
					ImageTex->MipGenSettings = TMGS_NoMipmaps;
					ImageTex->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);
					
					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTex->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTex->PlatformData->Mips[0].SizeY;
					
					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTex->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY* 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTex->PlatformData->Mips[0].BulkData.Unlock();

					ImageTex->UpdateResource();

					UpdateTextureData(ImageTex);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit"));
	}
}

void ASWP_MapTileManager::UpdateTextureData(const UTexture2D* ImageTex)
{
	for (int i = 0; i < planes.Num(); i++)
	{
		planes[i]->SetRelativeRotation(FRotator(0, 90, 0), false, nullptr, ETeleportType::None);
		planes[i]->SetVisibility(true);
		mInstance = UMaterialInstanceDynamic::Create(mTileInst, this);
		mInstance->SetVectorParameterValue("Color", FLinearColor::White);
		mInstance->SetTextureParameterValue("TileTexture", (UTexture*)ImageTex);
		planes[i]->SetMaterial(0, mInstance);
	}
}

*/
//Create functions to test how the textures are coming with the given lat lon coordinates

void ASWP_MapTileManager::CreateWebRequestPlane00(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if(DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 00 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane00);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane01(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 01 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane01);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane02(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane02);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane03(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane03);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane04(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane04);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane10(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 10 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane10);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane11(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 11 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane11);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane12(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 12 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane12);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane13(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane13);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane14(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 14 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane14);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane20(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 20 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane20);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane21(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 21 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane21);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane22(int zoomLevel, int XValue, int YValue, int qValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(qValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
	UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 22 with the end point as %s"), *urlFinal);
	
	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane22);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane23(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane23);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane24(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane24);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane30(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane30);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane31(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane31);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane32(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane32);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane33(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane33);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane34(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane34);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane40(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane40);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane41(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane41);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane42(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane42);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane43(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane43);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::CreateWebRequestPlane44(int zoomLevel, int XValue, int YValue, int QualityValue)
{
	FString urlString = TEXT("https://api.maptiler.com/maps/bright/2/0/1@2x.png?key=M5fYrAs6rDU728IMT3fG");
	FString urlLeft = TEXT("https://api.maptiler.com/maps/bright/");
	FString urlZoom = FString::FromInt(zoomLevel);
	FString urlTileXValue = FString::FromInt(XValue);
	FString urlTileYValue = FString::FromInt(YValue);
	FString strSlash = TEXT("/");
	FString urlQuality = TEXT("@") + FString::FromInt(QualityValue) + TEXT("x.png");
	FString urlRight = TEXT("?key=M5fYrAs6rDU728IMT3fG");
	FString urlFinal = urlLeft + urlZoom + strSlash + urlTileXValue + strSlash + urlTileYValue + urlQuality + urlRight;

	if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Creating API Request For Plane 02 with the end point as %s"), *urlFinal);

	TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
	HttpRequest->SetURL(urlFinal);
	HttpRequest->SetVerb(TEXT("GET"));
	HttpRequest->OnProcessRequestComplete().BindUObject(this, &ASWP_MapTileManager::OnLoadWebRequestFinishedPlane44);
	HttpRequest->ProcessRequest();
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane00(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 00"));
		
		IFileManager *eFileManager = &IFileManager::Get();

		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane00 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA
					ImageTexPlane00->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane00->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane00->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane00->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane00->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane00->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane00->UpdateResource();
					//SaveTileInDatabase(tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, tileStructureMap[plane00]->ZoomLevel, ImageTexPlane00*);
					
					
					UpdateTextureDatatoPlane00(ImageTexPlane00);
					//FAssetRegistryModule::AssetCreated(ImageTex);
					//SaveTileInDatabase(tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, tileStructureMap[plane00]->ZoomLevel, ImageTexPlane00);
					//SaveTileTexture(tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, tileStructureMap[plane00]->ZoomLevel, ImageTexPlane00);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit for Plane 00"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane01(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 01"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane01 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA
					ImageTexPlane01->MipGenSettings = TMGS_NoMipmaps;
#endif
					ImageTexPlane01->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane01->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane01->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane01->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane01->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane01->UpdateResource();

					UpdateTextureDatatoPlane01(ImageTexPlane01);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit for Plane 01"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane02(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 02"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane02 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane02->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane02->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane02->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane02->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane02->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane02->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane02->UpdateResource();

					UpdateTextureDatatoPlane02(ImageTexPlane02);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 02"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane03(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 03"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane03 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane03->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane03->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane03->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane03->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane03->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane03->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane03->UpdateResource();

					UpdateTextureDatatoPlane03(ImageTexPlane03);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 03"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane04(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 04"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane04 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane04->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane04->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane04->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane04->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane04->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane04->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane04->UpdateResource();

					UpdateTextureDatatoPlane04(ImageTexPlane04);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 04"));
	}
}



void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane10(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit from Plane 10"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			//UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane10 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane10->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane10->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane10->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane10->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane10->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane10->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane10->UpdateResource();

					UpdateTextureDatatoPlane10(ImageTexPlane10);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit From Plane 10"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane11(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit from Plane 11"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			//UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane11 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane11->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane11->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane11->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane11->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane11->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane11->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane11->UpdateResource();

					UpdateTextureDatatoPlane11(ImageTexPlane11);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from plane 11"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane12(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit from plane 12"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
		//	UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane12 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane12->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane12->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane12->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane12->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane12->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane12->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane12->UpdateResource();

					UpdateTextureDatatoPlane12(ImageTexPlane12);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 12"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane13(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 13"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane13 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane13->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane13->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane13->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane13->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane13->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane13->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane13->UpdateResource();

					UpdateTextureDatatoPlane13(ImageTexPlane13);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 13"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane14(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 14"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane14 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane14->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane14->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane14->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane14->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane14->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane14->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane14->UpdateResource();

					UpdateTextureDatatoPlane14(ImageTexPlane14);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 14"));
	}
}



void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane20(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit from Plane 20"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			//UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane20 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane20->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane20->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane20->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane20->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane20->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane20->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane20->UpdateResource();

					UpdateTextureDatatoPlane20(ImageTexPlane20);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 20"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane21(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit from plane 21"));
		
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
		//	UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane21 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA
					ImageTexPlane21->MipGenSettings = TMGS_NoMipmaps;
#endif					
					
					ImageTexPlane21->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane21->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane21->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane21->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane21->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane21->UpdateResource();

					UpdateTextureDatatoPlane21(ImageTexPlane21);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane22(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");
		
		if (DEBUG_TILEAPIREQUEST == 1)
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit"));
		
		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
		//	UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane22 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane22->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane22->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane22->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane22->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane22->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane22->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane22->UpdateResource();

					UpdateTextureDatatoPlane22(ImageTexPlane22);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from plane 22"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane23(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 23"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane23 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane23->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane23->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane23->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane23->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane23->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane23->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane23->UpdateResource();

					UpdateTextureDatatoPlane23(ImageTexPlane23);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 23"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane24(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 24"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane24 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane24->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane24->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane24->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane24->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane24->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane24->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane24->UpdateResource();

					UpdateTextureDatatoPlane24(ImageTexPlane24);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 24"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane30(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 30"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane30 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane30->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane30->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane30->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane30->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane30->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane30->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane30->UpdateResource();

					UpdateTextureDatatoPlane30(ImageTexPlane30);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 30"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane31(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 31"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane31 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane31->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane31->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane31->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane31->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane31->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane31->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane31->UpdateResource();

					UpdateTextureDatatoPlane31(ImageTexPlane31);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 31"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane32(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 32"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane32 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane32->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane32->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane32->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane32->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane32->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane32->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane32->UpdateResource();

					UpdateTextureDatatoPlane32(ImageTexPlane32);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 32"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane33(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 33"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane33 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane33->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane33->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane33->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane33->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane33->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane33->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane33->UpdateResource();

					UpdateTextureDatatoPlane33(ImageTexPlane33);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 33"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane34(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 34"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane34 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane34->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane34->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane34->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane34->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane34->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane34->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane34->UpdateResource();

					UpdateTextureDatatoPlane34(ImageTexPlane34);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 34"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane40(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 40"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane40 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane40->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane40->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane40->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane40->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane40->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane40->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane40->UpdateResource();

					UpdateTextureDatatoPlane40(ImageTexPlane40);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 40"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane41(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 41"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane41 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane41->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane41->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane41->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane41->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane41->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane41->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane41->UpdateResource();

					UpdateTextureDatatoPlane41(ImageTexPlane41);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 41"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane42(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 42"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane42 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane42->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane42->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane42->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane42->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane42->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane42->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane42->UpdateResource();

					UpdateTextureDatatoPlane42(ImageTexPlane42);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 42"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane43(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 43"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane43 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane43->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane43->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane43->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane43->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane43->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane43->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane43->UpdateResource();

					UpdateTextureDatatoPlane43(ImageTexPlane43);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 43"));
	}
}

void ASWP_MapTileManager::OnLoadWebRequestFinishedPlane44(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
	if (bWasSuccessful && Response.IsValid())
	{
		FString TestImageTxt = TEXT("Texture2D'/BlankPlugin/SWPContent/Materials/Textures/TestImage.TestImage'");

		if (DEBUG_TILEAPIREQUEST == 1)
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Valid Response from API hit for Plane 44"));

		IFileManager *eFileManager = &IFileManager::Get();


		IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
		TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
		TArray<uint8> ImageData = Response->GetContent();

		if (FFileHelper::SaveArrayToFile(ImageData, *TestImageTxt, eFileManager, 0U))
		{
			UE_LOG(LogSmartWorldPro, Warning, TEXT("Tried Saving the File"));
		}

		if (FFileHelper::LoadFileToArray(ImageData, *TestImageTxt))
		{
			if (ImageWrapper.IsValid() && ImageWrapper->SetCompressed(ImageData.GetData(), ImageData.Num()))
			{
				const TArray<uint8>* UncompressedBGRA = NULL;
				if (ImageWrapper->GetRaw(ERGBFormat::BGRA, 8, UncompressedBGRA))
				{
					ImageTexPlane44 = UTexture2D::CreateTransient(ImageWrapper->GetWidth(), ImageWrapper->GetHeight(), PF_B8G8R8A8);
#if WITH_EDITORONLY_DATA					
					ImageTexPlane44->MipGenSettings = TMGS_NoMipmaps;
#endif					
					ImageTexPlane44->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);

					//We need to get the height and width so that we do Realloc in Image Texture  
					int32 TexSizeX = ImageTexPlane44->PlatformData->Mips[0].SizeX;
					int32 TexSizeY = ImageTexPlane44->PlatformData->Mips[0].SizeY;

					//Find how the texture data is getting copied to Memcpy
					uint8* TextureData = (uint8*)ImageTexPlane44->PlatformData->Mips[0].BulkData.Realloc(TexSizeX * TexSizeY * 4);

					FMemory::Memcpy(TextureData, UncompressedBGRA->GetData(), UncompressedBGRA->Num());

					ImageTexPlane44->PlatformData->Mips[0].BulkData.Unlock();

					ImageTexPlane44->UpdateResource();

					UpdateTextureDatatoPlane44(ImageTexPlane44);
					//FAssetRegistryModule::AssetCreated(ImageTex);
				}
			}
		}

	}
	else
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Received Invalid Response From API hit from Plane 44"));
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane00(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane00->SetMaterial(0, mTileInstDyn);
	FString str1 = FString::FromInt(tileStructureMap[plane00]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane00]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane00]->ZoomLevel) + TEXT("Z"); // tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel
	//SaveTextureToDisk(ImageTexPlane00, str1);
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane00, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane01(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane01->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane01]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane01]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane01]->ZoomLevel) + TEXT("Z"); // tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel
	//SaveTextureToDisk(ImageTexPlane00, str1);
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane01, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane02(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane02->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane02]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane02]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane02]->ZoomLevel) + TEXT("Z"); // tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel
	//SaveTextureToDisk(ImageTexPlane00, str1);
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane02, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane03(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane03->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane03]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane03]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane03]->ZoomLevel) + TEXT("Z"); // tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel
	//SaveTextureToDisk(ImageTexPlane00, str1);
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane03, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane04(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane04->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane04]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane04]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane04]->ZoomLevel) + TEXT("Z"); // tileStructureMap[plane00]->ZoomLevel, tileStructureMap[plane00]->TileX, tileStructureMap[plane00]->TileY, qualityLevel
	//SaveTextureToDisk(ImageTexPlane00, str1);
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane04, str1);
	}
}


void ASWP_MapTileManager::UpdateTextureDatatoPlane10(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane10->SetMaterial(0, mTileInstDyn);
	
	FString str1 = FString::FromInt(tileStructureMap[plane10]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane10]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane10]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane10, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane11(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane11->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane11]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane11]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane11]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane11, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane12(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane12->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane12]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane12]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane12]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane12, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane13(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane13->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane13]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane13]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane13]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane13, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane14(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane14->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane14]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane14]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane14]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane14, str1);
	}
}


void ASWP_MapTileManager::UpdateTextureDatatoPlane20(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane20->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane20]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane20]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane20]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane20, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane21(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane21->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane21]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane21]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane21]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane21, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane22(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane22->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane22]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane22]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane22]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane22, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane23(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane23->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane23]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane23]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane23]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane23, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane24(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane24->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane24]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane24]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane24]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane24, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane30(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane30->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane30]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane30]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane30]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane30, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane31(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane31->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane31]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane31]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane31]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane31, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane32(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane32->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane32]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane32]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane32]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane32, str1);
	}
}


void ASWP_MapTileManager::UpdateTextureDatatoPlane33(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane33->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane33]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane33]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane33]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane33, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane34(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane34->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane34]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane34]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane34]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane34, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane40(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane40->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane40]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane40]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane40]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane40, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane41(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane41->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane41]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane41]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane41]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane41, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane42(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane42->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane42]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane42]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane42]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane42, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane43(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane43->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane43]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane43]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane43]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane43, str1);
	}
}

void ASWP_MapTileManager::UpdateTextureDatatoPlane44(const UTexture2D* img)
{
	mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
	mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
	mTileInstDyn->SetTextureParameterValue("TileTexture", (UTexture*)img);
	plane44->SetMaterial(0, mTileInstDyn);

	FString str1 = FString::FromInt(tileStructureMap[plane44]->TileX) + TEXT("X") + FString::FromInt(tileStructureMap[plane44]->TileY) + TEXT("Y") + FString::FromInt(tileStructureMap[plane44]->ZoomLevel) + TEXT("Z");
	if (AddTileIDinSaveGameObject(str1))
	{
		SaveTextureToDisk(ImageTexPlane44, str1);
	}
}



FVector2D ASWP_MapTileManager::GeoToWorldPosition(double latitude, double longitude, FVector2D refPoint, float Scale /* = 1 */)
{
	float posx = longitude * OriginShift / 180;
	float posy = FMath::Loge(FMath::Tan((90 + latitude) * PI / 360)) / (PI / 180);
	posy = posy * OriginShift / 180;
	return FVector2D((posx - refPoint.X) * Scale, (posy - refPoint.Y) * Scale);
}

float ASWP_MapTileManager::GetTileScaleInMeters(float latitude, int zoom)
{
	float ScaleValue = 40075016.685578 * (FMath::Cos(Deg2Rad * latitude) / FMath::Pow(2.f, zoom + 8));
	return ScaleValue;
}

float ASWP_MapTileManager::GetTileScaleInDegrees(float latitude, int zoom)
{
	return (float)(360.0f / FMath::Pow(2.f, zoom + 8));
}

FVector2D ASWP_MapTileManager::LatLonToMeters(double latitude, double longitude)
{
	float posx = longitude * OriginShift / 180;
	float posy = FMath::Loge(FMath::Tan((90 + latitude) * PI / 360)) / (PI / 180);
	posy = posy * OriginShift / 180;
	return FVector2D(posy, posx);
}

FVector2D ASWP_MapTileManager::PixelsToMeters(FVector2D p, int zoom)
{
	double res = Resolution(zoom);
	float resF = res;

	FVector2D vec1 = FVector2D((p.X * res) - OriginShift, -((p.Y * res) - OriginShift));
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Pixel To Meter Value is %s "), *vec1.ToString());
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Pixel To Meter || Vector P is %s "), *p.ToString());
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Pixel To Meter Value of Resolution %s "), *FString::SanitizeFloat(resF));
	return vec1;
}

FRectD ASWP_MapTileManager::TileBounds(FVector2D tileCoordinate, int zoom)
{
	FVector2D min = FVector2D::UnitVector;
	FVector2D max = FVector2D::UnitVector;
	min = PixelsToMeters(FVector2D(tileCoordinate.X * TileSize, tileCoordinate.Y * TileSize), zoom);
	max = PixelsToMeters(FVector2D((tileCoordinate.X + 1) * TileSize, (tileCoordinate.Y + 1) * TileSize), zoom);
	
	//min = PixelsToMeters(FVector2D(732 * TileSize, 426 * TileSize), zoom);
	//max = PixelsToMeters(FVector2D(733 * TileSize, 427 * TileSize), zoom);
	
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("In Tile Bounds method %s Min Vector Value "), *min.ToString());
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("In Tile Bounds method %s Max Vector Value "), *max.ToString());

	max = max - min;
	max = FVector2D((max.X), (max.Y));
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("In Tile Bounds method %s Min Vector Value "), *min.ToString());
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("In Tile Bounds method %s Max Vector Value "), *max.ToString());
	return FRectD(min, max);
}

void ASWP_MapTileManager::GetNewLocation(UStaticMeshComponent& mesh,int x,int y,int z)
{
	//FTileIDStruct IDStruct = CalculateTileIDForCenterGridElement(28.507878, 77.085348, zoomLevel);

	FRectD rectd = FRectD(FVector2D::ZeroVector, FVector2D::ZeroVector);
	rectd = TileBounds(FVector2D(x, y), zoomLevel);
	//FString str = FString::SanitizeFloat(rectd.Size.X);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("FRectD Size X Value : %s "), *str);
	rectd = rectd.ReverseXY(rectd);

	//float SizeByMeter = 0.f;
	auto SizeByMeter = 100 / ReferenceTileRect.Size.X;//plane11->GetComponentScale().X / ReferenceTileRect.Size.X;
	auto scaleFactor = 1;//FMath::Pow(2.f, zoomLevel);

	FVector newpos = FVector((rectd.Center.X - CenterMerc.X)*SizeByMeter*scaleFactor,
		(rectd.Center.Y - CenterMerc.Y)*SizeByMeter*scaleFactor, 0);
	//auto val1 = SizeByMeter * scaleFactor;

	//mesh.SetRelativeLocation(newpos,false,nullptr,ETeleportType::None);

	//FVector newpos = FVector(x*100,y*100,0);
	mesh.SetWorldLocation(newpos, false, nullptr, ETeleportType::None);

	if (DEBUG_TILEINITIALIZE == 1)
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("World Position is: %s  of Plane name: %s "), *newpos.ToString(),*mesh.GetName());
		UE_LOG(LogSmartWorldPro, Warning, TEXT("SizeByMeter is: %s  Scale Factor is : %s "), *FString::SanitizeFloat(SizeByMeter), *FString::SanitizeFloat(scaleFactor));
	}

	
}

void ASWP_MapTileManager::PanMapUsingKeyboard(float hValue,float vValue)
{
	float factor = panSpeed * GetTileScaleInDegrees(MapCenterLatLong.X,zoomLevel);
	FVector2D latitudeLongitude = FVector2D(MapCenterLatLong.X + hValue * factor * 2.0f, MapCenterLatLong.Y + vValue * factor * 2.0f);

	mapLat = latitudeLongitude.X;
	mapLon = latitudeLongitude.Y;

	MapCenterLatLong.X = latitudeLongitude.X;
	MapCenterLatLong.Y = latitudeLongitude.Y;

	if (DEBUG_TILEPANUPDATE == 1)
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("New Latitude name: %f "), mapLat);
		UE_LOG(LogSmartWorldPro, Warning, TEXT("New Longitude name: %f "), mapLon);
		UE_LOG(LogSmartWorldPro, Warning, TEXT("New ZoomLevel name: %d "), zoomLevel);
	}

	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);
	GenerateTileIDForGridElements(centerTileIDStruct);
	CreateWebRequestForTiles();

	RearrangeGridElements(mapLat, mapLon, tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY);

	
}

FVector2D ASWP_MapTileManager::WorldToGeographyPosition(FVector realWorldPosition)
{
	FVector2D refPoint = CenterMerc;
	double tscale = 1/ ReferenceTileRect.Size.X;
	//tscale = tscale * 1000;
	
	//auto final1 = FVector2D(realWorldPosition.Y / tscale, realWorldPosition.X / tscale);
	auto pos = refPoint + FVector2D(realWorldPosition.X/tscale,realWorldPosition.Y/tscale);
	
	if(DEBUG_TILEPOINTCLICK == 1)
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("TScale Value  %s and ZoomLevel Value: %s "), *FString::SanitizeFloat(tscale),*FString::FromInt(zoomLevel));
		UE_LOG(LogSmartWorldPro, Warning, TEXT("RefPoint  %s "), *refPoint.ToString());
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Resultant Position is    %s "), *pos.ToString());
	}
	pos = MetersToLatLon(pos);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Lat Lon of Location %s is ||   %s "),*realWorldPosition.ToString(), *pos.ToString());
	return pos;
}

FVector2D ASWP_MapTileManager::MetersToLatLon(FVector2D MeterPosition)
{
	double vx = 0.f, vy = 0.f;
	vx = (MeterPosition.Y / OriginShift) * 180;
	vy = (MeterPosition.X / OriginShift) * 180;
	vy = 180 / PI * (2 * FMath::Atan(FMath::Exp(vy * PI / 180)) - PI / 2);

	if (DEBUG_TILEPOINTCLICK == 1)
	{
		UE_LOG(LogSmartWorldPro, Warning, TEXT("VX:    %f "), vx);
		UE_LOG(LogSmartWorldPro, Warning, TEXT("VY:    %f "), vy);
	}
	
	return FVector2D(vy,vx);
}

void ASWP_MapTileManager::ResetPawnPosition(FVector Position)
{
	ASWP_WorldPlayerPawn* pwn = Cast<ASWP_WorldPlayerPawn>(GetWorld()->GetFirstPlayerController()->GetPawn());

	if (pwn)
	{
		pwn->SetActorLocation(Position, false, nullptr, ETeleportType::None);
	}
}

void ASWP_MapTileManager::RearrangeGridElements(double latitude, double longitude,int CenterX,int CenterY)
{
	MapCenterLatLong = FVector2D(latitude, longitude);
	ReferenceTileRect = TileBounds(FVector2D(CenterX, CenterY), zoomLevel);
	ReferenceTileRect = ReferenceTileRect.ReverseXY(ReferenceTileRect);
	CenterMerc = LatLonToMeters(latitude, longitude);

	if(DEBUG_TILEINITIALIZE == 1)
	{
		FVector2D vec2 = ReferenceTileRect.Center;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Reference Tile Rect Center Value %s "), *vec2.ToString());

		vec2 = ReferenceTileRect.Min;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Reference Tile Rect Min Value %s "), *vec2.ToString());

		vec2 = ReferenceTileRect.Max;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Reference Tile Rect Max Value %s "), *vec2.ToString());

		vec2 = ReferenceTileRect.Size;
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Reference Tile Rect Size Value %s "), *vec2.ToString());
	

		UE_LOG(LogSmartWorldPro, Warning, TEXT("Reference Tile Rect Size: %s  || Min: %s  || Max: %s   "), *ReferenceTileRect.Size.ToString(), *ReferenceTileRect.Min.ToString(), *ReferenceTileRect.Max.ToString());
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Center MErc: %s "), *CenterMerc.ToString());
	}

	for (int planeIndex = planes.Num()-1; planeIndex > -1;planeIndex--)
	{
		//planes[planeIndex]
		GetNewLocation(*planes[planeIndex],
						tileStructureMap[planes[planeIndex]]->TileX,
						tileStructureMap[planes[planeIndex]]->TileY,
						tileStructureMap[planes[planeIndex]]->ZoomLevel);
	} 
	
}


void ASWP_MapTileManager::CheckTileVisibleTimer()
{
	/*for (UStaticMeshComponent* Actor : planes)
	{
		FPrimitiveSceneInfo* sceneInfo = Actor->SceneProxy->GetPrimitiveSceneInfo();
		float floatpointer = sceneInfo->LastRenderTime;
	}*/


	FPrimitiveSceneInfo* sceneInfo = plane11->SceneProxy->GetPrimitiveSceneInfo();

	if (sceneInfo)
	{
		float floatpointer = sceneInfo->LastRenderTime;

		if (HUDRef)
			HUDRef->DebugStringValue = TEXT("Plane11: ") + FString::SanitizeFloat(floatpointer);
	}

	sceneInfo = plane00->SceneProxy->GetPrimitiveSceneInfo();

	if (sceneInfo)
	{
		float floatpointer = sceneInfo->LastRenderTime;

		if (HUDRef)
			HUDRef->DebugStringValue2 = TEXT("Plane00: ") + FString::SanitizeFloat(floatpointer);
	}

	sceneInfo = plane22->SceneProxy->GetPrimitiveSceneInfo();

	if (sceneInfo)
	{
		float floatpointer = sceneInfo->LastRenderTime;

		if (HUDRef)
			HUDRef->DebugStringValue3 = TEXT("Plane22: ") + FString::SanitizeFloat(floatpointer);
	}
}

void ASWP_MapTileManager::PanMapUsingMouse(const FVector2D& delMousePos)
{
	float factor = panSpeed * GetTileScaleInMeters(0, zoomLevel);
	auto latlongdelta = MetersToLatLon(FVector2D(delMousePos.X * factor, delMousePos.Y * factor));
	mapLat = mapLat + latlongdelta.X;
	mapLon = mapLon + latlongdelta.Y;
	HUDRef->DebugStringValue2 = TEXT("Lat: ") + FString::SanitizeFloat(mapLat) + TEXT(" Lon: ") + FString::SanitizeFloat(mapLon);
	
	mapLat = FMath::Clamp(mapLat, -mapLatMax, mapLatMax);
	mapLon = FMath::Clamp(mapLon, -mapLonMax, mapLonMax);

	/*Calculate the Center Tile ID Based on Zoom Level and MapLat And MapLon*/
	centerTileIDStruct = CalculateTileIDForCenterGridElement(mapLat, mapLon, zoomLevel);

	/*Generate Tile ID for all grid elements*/
	GenerateTileIDForGridElements(centerTileIDStruct);

	/*Create the Grid with the mentioned Rows and Colums*/
	CreateMapGrid(rows, columns);

	/*Create Web Request based on Tile Data calculated for each tile*/
	CreateWebRequestForTiles();

	//FVector2D newVEc = LatLonToMeters(28.507878, 77.085348);
	//UE_LOG(LogSmartWorldPro, Warning, TEXT("Center Tile in Meters is X: %f , Y : %f "), newVEc.X,newVEc.Y);

	/*Rearrange the tile components based on the Mercater Projection Coordinates*/
	RearrangeGridElements(mapLat, mapLon, tileStructureMap[plane11]->TileX, tileStructureMap[plane11]->TileY);

	//Calculate the position from center tile of the map
	worldPawn->ResetAfterPanLimit();

}


void ASWP_MapTileManager::SaveTileInDatabase(int TileX, int TileY, int zoomL, UTexture2D* tex2D)
{
	//FString PackageName = TEXT("/Game/MapTiles/");
	//FString TextureName = TEXT("Image101");
	//UPackage* Package = CreatePackage(NULL, *PackageName);
	//Package->FullyLoad();
	//int test_length = 1024;
	//uint8 TextureWidth = (uint8)test_length;
	//uint8 TextureHeight = (uint8)test_length;
	//

	//UTexture2D* NewTexture = NewObject<UTexture2D>(Package, *TextureName, RF_Public | RF_Standalone | RF_MarkAsRootSet);


	//const uint8* FormatedImageData = static_cast<const uint8*>(tex2D->PlatformData->Mips[0].BulkData.LockReadOnly());

	//NewTexture->AddToRoot();				// This line prevents garbage collection of the texture
	//NewTexture->PlatformData = new FTexturePlatformData();	// Then we initialize the PlatformData
	//NewTexture->PlatformData->SizeX = tex2D->GetSizeX();
	//NewTexture->PlatformData->SizeY = tex2D->GetSizeY();
	//NewTexture->PlatformData->NumSlices = 1;
	//NewTexture->PlatformData->PixelFormat = EPixelFormat::PF_B8G8R8A8;

	//uint8* Pixels = new uint8[TextureWidth * TextureHeight * 4];
	////Pixels = FormatedImageData;
	//
	//
	//for (int32 y = 0; y < TextureHeight; y++)
	//{
	//	for (int32 x = 0; x < TextureWidth; x++)
	//	{
	//		int32 curPixelIndex = ((y * TextureWidth) + x);
	//		Pixels[4 * curPixelIndex] = 122;
	//		Pixels[4 * curPixelIndex + 1] = 122;
	//		Pixels[4 * curPixelIndex + 2] = 122;
	//		Pixels[4 * curPixelIndex + 3] = 122;
	//	}
	//}

	//// Allocate first mipmap.
	//FTexture2DMipMap* Mip = new(NewTexture->PlatformData->Mips) FTexture2DMipMap();
	//Mip->SizeX = TextureWidth;
	//Mip->SizeY = TextureHeight;

	//// Lock the texture so it can be modified
	//Mip->BulkData.Lock(LOCK_READ_WRITE);
	//uint8* TextureData = (uint8*)Mip->BulkData.Realloc(TextureWidth * TextureHeight * 4);
	//FMemory::Memcpy(TextureData, Pixels, sizeof(uint8) * TextureHeight * TextureWidth * 4);
	//Mip->BulkData.Unlock();

	//NewTexture->Source.Init(TextureWidth, TextureHeight, 1, 1, ETextureSourceFormat::TSF_BGRA8, Pixels);

	//NewTexture->UpdateResource();
	//Package->MarkPackageDirty();
	//FAssetRegistryModule::AssetCreated(NewTexture);

	//FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());
	//bool bSaved = UPackage::SavePackage(Package, NewTexture, EObjectFlags::RF_Public | EObjectFlags::RF_Standalone, *PackageFileName, GError, nullptr, true, true, SAVE_NoError);

	//delete[] Pixels;


}

void ASWP_MapTileManager::SaveTileTexture(int TileX, int TileY, int zoomL, UTexture2D * tex2D)
{
	FString PackageName = TEXT("/Game/MapTiles/");
	FString TextureName = TEXT("Image101");
	UPackage* Package = CreatePackage(NULL, *PackageName);
	Package->FullyLoad();
	


	FString DirName = TEXT("/Game/MapTiles/");
	FString FileName = TEXT("Image101");
	
	TextureCompressionSettings prevCompression = tex2D->CompressionSettings;
#if WITH_EDITORONLY_DATA
	TextureMipGenSettings preMipSettings = tex2D->MipGenSettings;
#endif
	tex2D->CompressionSettings = TextureCompressionSettings::TC_VectorDisplacementmap;
#if WITH_EDITORONLY_DATA
	tex2D->MipGenSettings = TextureMipGenSettings::TMGS_NoMipmaps;
#endif	
	tex2D->UpdateResource();
	FTexture2DMipMap* MM = &tex2D->PlatformData->Mips[0];

	TArray<FColor> OutBMP;
	int w = MM->SizeX;
	int h = MM->SizeY;

	OutBMP.SetNumUninitialized(w*h);

	FByteBulkData* RawImageData = &MM->BulkData;

	//FColor* FormatedImageData = static_cast<FColor*>(RawImageData->Lock(LOCK_READ_WRITE));
	uint8* FormatedImageByteData = static_cast<uint8*>(RawImageData->Lock(LOCK_READ_WRITE));

//	if (FormatedImageData && FormatedImageData)
	if(FormatedImageByteData)
	{
		/*for (int i = 0; i < (w * h); ++i)
		{
			OutBMP[i] = FormatedImageData[i];
			OutBMP[i].A = 255;
		}*/

		RawImageData->Unlock();
		FIntPoint DestSize(w, h);

		FString ResultPath;
		FHighResScreenshotConfig& HighResScreenshotConfig = GetHighResScreenshotConfig();
		//HighResScreenshotConfig.Init();	//SaveImage(FileName, OutBMP, DestSize, nullptr);
		//HighResScreenshotConfig.ImageWriteQueue
		if (!ensureMsgf(HighResScreenshotConfig.ImageWriteQueue, TEXT("Unable to write images unless FHighResScreenshotConfig::Init has been called.")))
		{
			// Do something
		}
		int test_length = 1024;
		uint8 TextureWidth = (uint8)test_length; 
		uint8 TextureHeight = (uint8)test_length;

		UE_LOG(LogSmartWorldPro, Warning, TEXT("Texture Width: %d "), TextureWidth);
		UE_LOG(LogSmartWorldPro, Warning, TEXT("Texture Height: %d "), TextureHeight);

		UTexture2D* NewTexture = NewObject<UTexture2D>(Package, *TextureName, RF_Public | RF_Standalone | RF_MarkAsRootSet);
		NewTexture->AddToRoot();// This line prevents garbage collection of the texture
		NewTexture->PlatformData = new FTexturePlatformData();	// Then we initialize the PlatformData
		NewTexture->PlatformData->SizeX = TextureWidth;
		NewTexture->PlatformData->SizeY = TextureHeight;
		NewTexture->PlatformData->NumSlices = 1;
		NewTexture->PlatformData->PixelFormat = EPixelFormat::PF_B8G8R8A8;
		
		FTexture2DMipMap* Mip = new(NewTexture->PlatformData->Mips) FTexture2DMipMap();
		Mip->SizeX = TextureWidth;
		Mip->SizeY = TextureHeight;
		
		NewTexture->CompressionSettings = TextureCompressionSettings::TC_Displacementmap;
#if WITH_EDITORONLY_DATA
		NewTexture->MipGenSettings = TextureMipGenSettings::TMGS_NoMipmaps;
#endif
		Mip->BulkData.Lock(LOCK_READ_WRITE);
		uint8* TextureData = (uint8*)Mip->BulkData.Realloc(TextureWidth * TextureHeight * 4);
		FMemory::Memcpy(TextureData, FormatedImageByteData, sizeof(uint8) * TextureHeight * TextureWidth * 4);
		Mip->BulkData.Unlock();


		//NewTexture->Source.Init(TextureWidth, TextureHeight, 1, 1, ETextureSourceFormat::TSF_BGRA8, FormatedImageByteData);
		
		/*NewTexture->UpdateResource();
		Package->SetDirtyFlag(true);
		FAssetRegistryModule::AssetCreated(NewTexture);*/

		FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());
		bool bSaved = UPackage::SavePackage(Package, NewTexture, EObjectFlags::RF_Public | EObjectFlags::RF_Standalone, *PackageFileName, GError, nullptr, true, true, SAVE_NoError);

		delete FormatedImageByteData;

		
		
		
		
		
		
		
		
		
		
		
		// Create ImageTask
		//TUniquePtr<FImageWriteTask> ImageTask = MakeUnique<FImageWriteTask>();

		//// Pass bitmap to pixeldata
		//ImageTask->PixelData = MakeUnique<TImagePixelData<FLinearColor>>(DestSize, MoveTemp(OutBMP));
		//ImageTask->PixelData = TUniquePtr<TImagePixelData<FLinearColor>>(DestSize, MoveTemp(OutBMP));

		//// Populate Task with config data
		//HighResScreenshotConfig.PopulateImageTaskParams(*ImageTask);
		//ImageTask->Filename = FileName;

		//// Specify HDR as output format
		////ImageTask->Format = EImageFormat::HDR;

		//// Save the bitmap to disc
		//TFuture<bool> CompletionFuture = HighResScreenshotConfig.ImageWriteQueue->Enqueue(MoveTemp(ImageTask));
		//if (CompletionFuture.IsValid())
		//{
		//	CompletionFuture.Wait();
		//}


	}
	else
	{
		UE_LOG(LogTemp, Error, TEXT("SaveTextureToDisk: could not access bulk data of texture! Texture: %s"), *tex2D->GetFullName());
	}

	tex2D->CompressionSettings = prevCompression;
#if WITH_EDITORONLY_DATA
	tex2D->MipGenSettings = preMipSettings;
#endif
}

void ASWP_MapTileManager::SaveTextureToDisk(UTexture2D* texture, const FString& file)
{
//	FString str1 = FString::FromInt(tileStructureMap[plane00]->TileX) + TEXT("/") + FString::FromInt(tileStructureMap[plane00]->TileY) + TEXT("/") + FString::FromInt(tileStructureMap[plane00]->ZoomLevel);
	FString ThePath = FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + TEXT("MapTiles/") + file;
	
	
	//UE_LOG(LogTemp, Warning, TEXT("Path name is : %s"), *ThePath);
	
	// Here I tried to work with a temporary texture, but that did not work. Changing the settings
	// of the texture after copy did not have effect.
	//UTexture2D* tempTex = texture->CreateTransient(texture->GetSizeX(), texture->GetSizeY());
	//void* dest = tempTex->PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);
	//texture->PlatformData->Mips[0].BulkData.GetCopy(&dest, false);
	//tempTex->PlatformData->Mips[0].BulkData.Unlock();
	//tempTex->CompressionSettings = TextureCompressionSettings::TC_VectorDisplacementmap;
	//tempTex->MipGenSettings = TextureMipGenSettings::TMGS_NoMipmaps;
	//tempTex->UpdateResource();

	//TextureCompressionSettings prevCompression = texture->CompressionSettings;
	//TextureMipGenSettings prevMipSettings = texture->MipGenSettings;
	//texture->CompressionSettings = TextureCompressionSettings::TC_VectorDisplacementmap;
	//texture->MipGenSettings = TextureMipGenSettings::TMGS_NoMipmaps;
	//texture->UpdateResource();
	//FTexture2DMipMap* MM = &texture->PlatformData->Mips[0];

	//TArray<FColor> OutBMP;
	//int w = MM->SizeX;
	//int h = MM->SizeY;

	//OutBMP.SetNumUninitialized(w*h);

	//FByteBulkData* RawImageData = &MM->BulkData;

	//FColor* FormatedImageData = static_cast<FColor*>(RawImageData->Lock(LOCK_READ_ONLY));
	//if (FormatedImageData)
	//{
	//	for (int i = 0; i < (w*h); ++i)
	//	{
	//		OutBMP[i] = FormatedImageData[i];
	//		OutBMP[i].A = 255;
	//	}

	//	RawImageData->Unlock();
	//	FIntPoint DestSize(w, h);

	//	FString ResultPath;
	//	FHighResScreenshotConfig& HighResScreenshotConfig = GetHighResScreenshotConfig();
	//	//HighResScreenshotConfig.SaveImage(file, OutBMP, DestSize, nullptr);
	//	
	//}
	//else
	//{
	//	UE_LOG(LogTemp, Error, TEXT("SaveTextureToDisk: could not access bulk data of texture! Texture: %s"), *texture->GetFullName());
	//}

	//texture->CompressionSettings = prevCompression;
	//texture->MipGenSettings = prevMipSettings;




	FImageWriteOptions FOptions;
	FOptions.bAsync = true;
	FOptions.bOverwriteFile = true;
	FOptions.CompressionQuality = 1;
	FOptions.Format = EDesiredImageFormat::PNG;
	UImageWriteBlueprintLibrary::ExportToDisk(texture, ThePath, FOptions);
}

bool ASWP_MapTileManager::InstantiateSaveGameObject()
{
	bool bLoaded = false;

	mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::CreateSaveGameObject(USWP_SaveManager::StaticClass()));
	mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::LoadGameFromSlot(mSaveGameSlot->SaveSlotName, 0));

	if (mSaveGameSlot != nullptr)
	{
		bLoaded = true;
		UE_LOG(LogSaveGameManager, Warning, TEXT("Load Save Game Object Successful!"));
		ManagerTileList = mSaveGameSlot->MapTileList;
	}
	else
	{
		mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::CreateSaveGameObject(USWP_SaveManager::StaticClass()));
		check(mSaveGameSlot)
		{
			UE_LOG(LogSaveGameManager, Warning, TEXT("Create Save Game Instance successful!"));
			mSaveGameSlot->PlayerName = TEXT("SWP Player");
			mSaveGameSlot->MapTileList.Empty();
			ManagerTileList = mSaveGameSlot->MapTileList;
			if (UGameplayStatics::SaveGameToSlot(mSaveGameSlot, mSaveGameSlot->SaveSlotName, 0))
			{
				UE_LOG(LogSaveGameManager, Warning, TEXT("Added Custom Player Name to Save Game Object!"));
			}
		}
	}

	return bLoaded;
}

bool ASWP_MapTileManager::FindTileMapInDatabase(FString texName)
{
	bool bLoaded = false;
	FString mapTileName = TEXT("Image01");

	//check(mSaveGameSlot)
	if (ManagerTileList.Num() < 1)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("NO Items in the Save Game Object"));
		return bLoaded;
	}

	//if (mSaveGameSlot->MapTileList.Contains(texName))
	int32 indexID = 0;
	if (ManagerTileList.Find(texName,indexID))
	{
		bLoaded = true;
		UE_LOG(LogSaveGameManager, Warning, TEXT("Found the item in Save Game Object"));
		return bLoaded;
	}
	else
	{
		bLoaded = false;
		UE_LOG(LogSaveGameManager, Warning, TEXT("Item not found in the Save Game Object"));
	}



	return bLoaded;
}

bool ASWP_MapTileManager::AddTileIDinSaveGameObject(FString texName)
{
	bool bAdded = false;
	//check(mSaveGameSlot)
	
	if (ManagerTileList.Contains(texName))
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Cannot Add Texture Name, already present in the list."));
		return bAdded;
	}
	else
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Added the item in the list."));
		ManagerTileList.Add(texName);
		currentSaveTimer = SaveTimer;
		bCheckSaveTimer = true;
		bAdded = true;
	}
	return bAdded;
}

bool ASWP_MapTileManager::SaveTileData()
{
	bool sResult = false;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Calling Save Function."));
	//mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::CreateSaveGameObject(USWP_SaveManager::StaticClass()));
	//mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::LoadGameFromSlot(mSaveGameSlot->SaveSlotName, 0));
	check(mSaveGameSlot)
		mSaveGameSlot->MapTileList.Empty();
	mSaveGameSlot->MapTileList.Reserve(ManagerTileList.Num());
	mSaveGameSlot->MapTileList = ManagerTileList;

	if (UGameplayStatics::SaveGameToSlot(mSaveGameSlot, TEXT("A1"), 0))
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Saving Values...!"));
		mSaveGameSlot = Cast<USWP_SaveManager>(UGameplayStatics::LoadGameFromSlot(TEXT("A1"), 0));

		if(mSaveGameSlot != nullptr)
		{ 
			UE_LOG(LogSaveGameManager, Warning, TEXT("Loaded New Values in Save Game Object!"));
			ManagerTileList = mSaveGameSlot->MapTileList;
		}
		sResult = true;
	}
	return sResult;
}

void ASWP_MapTileManager::LoadSavedTexturePlane00(FString loadStr)
{
//	const TCHAR* tchar = *loadStr;
	FString loadStr1 = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".")+loadStr + TEXT("'");
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/730X426Y10Z.730X426Y10Z'");
	const TCHAR* tchar = *loadStr1;

	//UE_LOG(LogSaveGameManager, Warning, TEXT("%s"), *loadStr1);
	//UE_LOG(LogSaveGameManager, Warning, TEXT("%s"), *loadedStr);
	
	
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		//UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 00"));
		
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane00->SetMaterial(0, mTileInstDyn);
	}
	
}

void ASWP_MapTileManager::LoadSavedTexturePlane01(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;

	if (DEBUG_TILETEXTURE == DEBUG_ON)
	{ 
		UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	}
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		if (DEBUG_TILETEXTURE == DEBUG_ON)
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 01"));
		
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane01->SetMaterial(0, mTileInstDyn);
	}

}

void ASWP_MapTileManager::LoadSavedTexturePlane02(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;

	if (DEBUG_TILETEXTURE == DEBUG_ON)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
		UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	}
	
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		if (DEBUG_TILETEXTURE == DEBUG_ON)
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 02"));
		
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane02->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane03(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 02"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane03->SetMaterial(0, mTileInstDyn);
	}
}

void ASWP_MapTileManager::LoadSavedTexturePlane04(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 02"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane04->SetMaterial(0, mTileInstDyn);
	}
}

void ASWP_MapTileManager::LoadSavedTexturePlane10(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 10"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane10->SetMaterial(0, mTileInstDyn);
	}

}

void ASWP_MapTileManager::LoadSavedTexturePlane11(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 11"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane11->SetMaterial(0, mTileInstDyn);
	}
}



void ASWP_MapTileManager::LoadSavedTexturePlane12(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 12"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane12->SetMaterial(0, mTileInstDyn);
	}
}

void ASWP_MapTileManager::LoadSavedTexturePlane13(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 11"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane13->SetMaterial(0, mTileInstDyn);
	}
}



void ASWP_MapTileManager::LoadSavedTexturePlane14(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 12"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane14->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane20(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 20"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane20->SetMaterial(0, mTileInstDyn);
	}

}


void ASWP_MapTileManager::LoadSavedTexturePlane21(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane21->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane22(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane22->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane23(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane23->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane24(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane24->SetMaterial(0, mTileInstDyn);
	}
}

void ASWP_MapTileManager::LoadSavedTexturePlane30(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 20"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane30->SetMaterial(0, mTileInstDyn);
	}

}


void ASWP_MapTileManager::LoadSavedTexturePlane31(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane31->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane32(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane32->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane33(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane33->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane34(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane34->SetMaterial(0, mTileInstDyn);
	}
}

void ASWP_MapTileManager::LoadSavedTexturePlane40(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 20"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane40->SetMaterial(0, mTileInstDyn);
	}

}


void ASWP_MapTileManager::LoadSavedTexturePlane41(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane41->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane42(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane42->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane43(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 21"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane43->SetMaterial(0, mTileInstDyn);
	}
}


void ASWP_MapTileManager::LoadSavedTexturePlane44(FString loadStr)
{
	//	const TCHAR* tchar = *loadStr;
	FString  loadedStr = TEXT("Texture2D'/Game/MapTiles/") + loadStr + TEXT(".") + loadStr + TEXT("'");;
	const TCHAR* tchar = *loadedStr;
	UE_LOG(LogSaveGameManager, Warning, TEXT("Load Path is: %s"), *loadStr);
	UE_LOG(LogSaveGameManager, Warning, TEXT("Original Path is Path is: %s"), *loadedStr);
	if (loadStr.IsEmpty())
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Texture path is empty"));
		return;
	}

	//UTexture* tempTex2D = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, *(loadStr)));
	//UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, TEXT("730X426Y10Z"),tchar,LOAD_None,nullptr);// , NULL, LOAD_None, NULL);
	UTexture2D* tempTex2D = LoadObject<UTexture2D>(nullptr, tchar, nullptr, LOAD_None, NULL);

	if (tempTex2D != nullptr)
	{
		UE_LOG(LogSaveGameManager, Warning, TEXT("Got the texture. Saving Texture in Plane 22"));
		mTileInstDyn = UMaterialInstanceDynamic::Create(mTileInst, this);
		mTileInstDyn->SetVectorParameterValue("Color", FLinearColor::White);
		mTileInstDyn->SetTextureParameterValue("TileTexture", tempTex2D);
		plane44->SetMaterial(0, mTileInstDyn);
	}
}