1265 lines
37 KiB
C++
1265 lines
37 KiB
C++
// Copyright Ralpha Team. All Rights Reserved.
|
|
|
|
#include "RalphaParameterBridge.h"
|
|
#include "RalphaMCPServer.h"
|
|
#include "Engine/Engine.h"
|
|
#include "Engine/World.h"
|
|
#include "Engine/PostProcessVolume.h"
|
|
#include "Engine/DirectionalLight.h"
|
|
#include "Engine/SkyLight.h"
|
|
#include "Engine/ExponentialHeightFog.h"
|
|
#include "CineCameraActor.h"
|
|
#include "CineCameraComponent.h"
|
|
#include "Components/PostProcessComponent.h"
|
|
#include "Components/DirectionalLightComponent.h"
|
|
#include "Components/SkyLightComponent.h"
|
|
#include "Components/ExponentialHeightFogComponent.h"
|
|
#include "Kismet/GameplayStatics.h"
|
|
#include "EngineUtils.h"
|
|
#include "AssetRegistry/AssetRegistryModule.h"
|
|
#include "Engine/StaticMeshActor.h"
|
|
#include "Engine/StaticMesh.h"
|
|
#include "Components/SkyAtmosphereComponent.h"
|
|
#include "Components/VolumetricCloudComponent.h"
|
|
#include "Dom/JsonObject.h"
|
|
#include "Dom/JsonValue.h"
|
|
#include "Serialization/JsonSerializer.h"
|
|
#include "Materials/MaterialInstanceDynamic.h"
|
|
|
|
URalphaParameterBridge::URalphaParameterBridge()
|
|
{
|
|
}
|
|
|
|
UWorld* URalphaParameterBridge::GetCurrentWorld()
|
|
{
|
|
if (GEngine && GEngine->GetWorldContexts().Num() > 0)
|
|
{
|
|
for (const FWorldContext& Context : GEngine->GetWorldContexts())
|
|
{
|
|
if (Context.WorldType == EWorldType::Editor || Context.WorldType == EWorldType::PIE)
|
|
{
|
|
return Context.World();
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
APostProcessVolume* URalphaParameterBridge::FindPostProcessVolume()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return nullptr;
|
|
|
|
for (TActorIterator<APostProcessVolume> It(World); It; ++It)
|
|
{
|
|
if (It->bUnbound) // Prefer unbound (global) volumes
|
|
{
|
|
return *It;
|
|
}
|
|
}
|
|
|
|
// Return any post-process volume if no unbound one found
|
|
for (TActorIterator<APostProcessVolume> It(World); It; ++It)
|
|
{
|
|
return *It;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
ADirectionalLight* URalphaParameterBridge::FindDirectionalLight()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return nullptr;
|
|
|
|
for (TActorIterator<ADirectionalLight> It(World); It; ++It)
|
|
{
|
|
return *It;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
ASkyLight* URalphaParameterBridge::FindSkyLight()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return nullptr;
|
|
|
|
for (TActorIterator<ASkyLight> It(World); It; ++It)
|
|
{
|
|
return *It;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
AExponentialHeightFog* URalphaParameterBridge::FindExponentialHeightFog()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return nullptr;
|
|
|
|
for (TActorIterator<AExponentialHeightFog> It(World); It; ++It)
|
|
{
|
|
return *It;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
ACineCameraActor* URalphaParameterBridge::FindCineCamera()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return nullptr;
|
|
|
|
for (TActorIterator<ACineCameraActor> It(World); It; ++It)
|
|
{
|
|
return *It;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
FLinearColor URalphaParameterBridge::ParseHexColor(const FString& HexColor)
|
|
{
|
|
FString CleanHex = HexColor;
|
|
CleanHex.RemoveFromStart(TEXT("#"));
|
|
|
|
FColor Color = FColor::FromHex(CleanHex);
|
|
return FLinearColor(Color);
|
|
}
|
|
|
|
FString URalphaParameterBridge::ColorToHex(const FLinearColor& Color)
|
|
{
|
|
FColor SRGBColor = Color.ToFColor(true);
|
|
return FString::Printf(TEXT("#%02X%02X%02X"), SRGBColor.R, SRGBColor.G, SRGBColor.B);
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetAllParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
Result->SetObjectField(TEXT("post_process"), GetPostProcessParameters());
|
|
Result->SetObjectField(TEXT("directional_light"), GetDirectionalLightParameters());
|
|
Result->SetObjectField(TEXT("sky_light"), GetSkyLightParameters());
|
|
Result->SetObjectField(TEXT("fog"), GetFogParameters());
|
|
Result->SetObjectField(TEXT("camera"), GetCameraParameters());
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Post-Process Volume
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetPostProcessParameters(const TSharedPtr<FJsonObject>& Params)
|
|
{
|
|
APostProcessVolume* PPV = FindPostProcessVolume();
|
|
if (!PPV)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("No PostProcessVolume found in scene"));
|
|
return false;
|
|
}
|
|
|
|
FPostProcessSettings& Settings = PPV->Settings;
|
|
|
|
// Exposure
|
|
if (Params->HasField(TEXT("exposure_compensation")))
|
|
{
|
|
Settings.bOverride_AutoExposureBias = true;
|
|
Settings.AutoExposureBias = Params->GetNumberField(TEXT("exposure_compensation"));
|
|
}
|
|
|
|
// Color Grading
|
|
if (Params->HasField(TEXT("color_saturation")))
|
|
{
|
|
Settings.bOverride_ColorSaturation = true;
|
|
float Sat = Params->GetNumberField(TEXT("color_saturation"));
|
|
Settings.ColorSaturation = FVector4(Sat, Sat, Sat, 1.0f);
|
|
}
|
|
|
|
if (Params->HasField(TEXT("color_contrast")))
|
|
{
|
|
Settings.bOverride_ColorContrast = true;
|
|
float Contrast = Params->GetNumberField(TEXT("color_contrast"));
|
|
Settings.ColorContrast = FVector4(Contrast, Contrast, Contrast, 1.0f);
|
|
}
|
|
|
|
// White Balance
|
|
if (Params->HasField(TEXT("white_balance_temp")))
|
|
{
|
|
Settings.bOverride_WhiteTemp = true;
|
|
Settings.WhiteTemp = Params->GetNumberField(TEXT("white_balance_temp"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("white_balance_tint")))
|
|
{
|
|
Settings.bOverride_WhiteTint = true;
|
|
Settings.WhiteTint = Params->GetNumberField(TEXT("white_balance_tint"));
|
|
}
|
|
|
|
// Bloom
|
|
if (Params->HasField(TEXT("bloom_intensity")))
|
|
{
|
|
Settings.bOverride_BloomIntensity = true;
|
|
Settings.BloomIntensity = Params->GetNumberField(TEXT("bloom_intensity"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("bloom_threshold")))
|
|
{
|
|
Settings.bOverride_BloomThreshold = true;
|
|
Settings.BloomThreshold = Params->GetNumberField(TEXT("bloom_threshold"));
|
|
}
|
|
|
|
// Vignette
|
|
if (Params->HasField(TEXT("vignette_intensity")))
|
|
{
|
|
Settings.bOverride_VignetteIntensity = true;
|
|
Settings.VignetteIntensity = Params->GetNumberField(TEXT("vignette_intensity"));
|
|
}
|
|
|
|
// Film Grain
|
|
if (Params->HasField(TEXT("film_grain_intensity")))
|
|
{
|
|
Settings.bOverride_FilmGrainIntensity = true;
|
|
Settings.FilmGrainIntensity = Params->GetNumberField(TEXT("film_grain_intensity"));
|
|
}
|
|
|
|
// Chromatic Aberration
|
|
if (Params->HasField(TEXT("chromatic_aberration_intensity")))
|
|
{
|
|
Settings.bOverride_SceneFringeIntensity = true;
|
|
Settings.SceneFringeIntensity = Params->GetNumberField(TEXT("chromatic_aberration_intensity"));
|
|
}
|
|
|
|
PPV->MarkPackageDirty();
|
|
return true;
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetPostProcessParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
APostProcessVolume* PPV = FindPostProcessVolume();
|
|
if (!PPV)
|
|
{
|
|
return Result;
|
|
}
|
|
|
|
const FPostProcessSettings& Settings = PPV->Settings;
|
|
|
|
Result->SetNumberField(TEXT("exposure_compensation"), Settings.AutoExposureBias);
|
|
Result->SetNumberField(TEXT("color_saturation"), Settings.ColorSaturation.X);
|
|
Result->SetNumberField(TEXT("color_contrast"), Settings.ColorContrast.X);
|
|
Result->SetNumberField(TEXT("white_balance_temp"), Settings.WhiteTemp);
|
|
Result->SetNumberField(TEXT("white_balance_tint"), Settings.WhiteTint);
|
|
Result->SetNumberField(TEXT("bloom_intensity"), Settings.BloomIntensity);
|
|
Result->SetNumberField(TEXT("bloom_threshold"), Settings.BloomThreshold);
|
|
Result->SetNumberField(TEXT("vignette_intensity"), Settings.VignetteIntensity);
|
|
Result->SetNumberField(TEXT("film_grain_intensity"), Settings.FilmGrainIntensity);
|
|
Result->SetNumberField(TEXT("chromatic_aberration_intensity"), Settings.SceneFringeIntensity);
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Directional Light
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetDirectionalLightParameters(const TSharedPtr<FJsonObject>& Params)
|
|
{
|
|
ADirectionalLight* Light = FindDirectionalLight();
|
|
if (!Light)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("No DirectionalLight found in scene"));
|
|
return false;
|
|
}
|
|
|
|
UDirectionalLightComponent* LightComp = Cast<UDirectionalLightComponent>(Light->GetLightComponent());
|
|
if (!LightComp) return false;
|
|
|
|
if (Params->HasField(TEXT("intensity")))
|
|
{
|
|
LightComp->SetIntensity(Params->GetNumberField(TEXT("intensity")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("color")))
|
|
{
|
|
FLinearColor Color = ParseHexColor(Params->GetStringField(TEXT("color")));
|
|
LightComp->SetLightColor(Color);
|
|
}
|
|
|
|
if (Params->HasField(TEXT("temperature")))
|
|
{
|
|
LightComp->bUseTemperature = true;
|
|
LightComp->SetTemperature(Params->GetNumberField(TEXT("temperature")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("pitch")) || Params->HasField(TEXT("yaw")))
|
|
{
|
|
FRotator CurrentRot = Light->GetActorRotation();
|
|
if (Params->HasField(TEXT("pitch")))
|
|
{
|
|
CurrentRot.Pitch = Params->GetNumberField(TEXT("pitch"));
|
|
}
|
|
if (Params->HasField(TEXT("yaw")))
|
|
{
|
|
CurrentRot.Yaw = Params->GetNumberField(TEXT("yaw"));
|
|
}
|
|
Light->SetActorRotation(CurrentRot);
|
|
}
|
|
|
|
if (Params->HasField(TEXT("source_angle")))
|
|
{
|
|
LightComp->LightSourceAngle = Params->GetNumberField(TEXT("source_angle"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("source_soft_angle")))
|
|
{
|
|
LightComp->LightSourceSoftAngle = Params->GetNumberField(TEXT("source_soft_angle"));
|
|
}
|
|
|
|
LightComp->MarkRenderStateDirty();
|
|
|
|
// Refresh any BP_Sky_Sphere to update based on new sun position
|
|
RefreshSkySphere();
|
|
|
|
return true;
|
|
}
|
|
|
|
void URalphaParameterBridge::RefreshSkySphere()
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return;
|
|
|
|
ADirectionalLight* DirectionalLight = FindDirectionalLight();
|
|
|
|
// Find BP_Sky_Sphere and refresh it
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
FString ClassName = It->GetClass()->GetName();
|
|
if (ClassName.Contains(TEXT("BP_Sky")))
|
|
{
|
|
AActor* SkySphere = *It;
|
|
|
|
// Ensure directional light is linked
|
|
if (DirectionalLight)
|
|
{
|
|
FProperty* DirLightProp = SkySphere->GetClass()->FindPropertyByName(TEXT("Directional light actor"));
|
|
if (!DirLightProp)
|
|
{
|
|
DirLightProp = SkySphere->GetClass()->FindPropertyByName(TEXT("DirectionalLightActor"));
|
|
}
|
|
if (DirLightProp)
|
|
{
|
|
FObjectProperty* ObjProp = CastField<FObjectProperty>(DirLightProp);
|
|
if (ObjProp)
|
|
{
|
|
ObjProp->SetObjectPropertyValue_InContainer(SkySphere, DirectionalLight);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Call RefreshMaterial function
|
|
UFunction* RefreshFunc = SkySphere->FindFunction(TEXT("RefreshMaterial"));
|
|
if (RefreshFunc)
|
|
{
|
|
SkySphere->ProcessEvent(RefreshFunc, nullptr);
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("Refreshed BP_Sky_Sphere material"));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetDirectionalLightParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
ADirectionalLight* Light = FindDirectionalLight();
|
|
if (!Light) return Result;
|
|
|
|
UDirectionalLightComponent* LightComp = Cast<UDirectionalLightComponent>(Light->GetLightComponent());
|
|
if (!LightComp) return Result;
|
|
|
|
Result->SetNumberField(TEXT("intensity"), LightComp->Intensity);
|
|
Result->SetStringField(TEXT("color"), ColorToHex(LightComp->GetLightColor()));
|
|
Result->SetNumberField(TEXT("temperature"), LightComp->Temperature);
|
|
Result->SetNumberField(TEXT("pitch"), Light->GetActorRotation().Pitch);
|
|
Result->SetNumberField(TEXT("yaw"), Light->GetActorRotation().Yaw);
|
|
Result->SetNumberField(TEXT("source_angle"), LightComp->LightSourceAngle);
|
|
Result->SetNumberField(TEXT("source_soft_angle"), LightComp->LightSourceSoftAngle);
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Sky Light
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetSkyLightParameters(const TSharedPtr<FJsonObject>& Params)
|
|
{
|
|
ASkyLight* Light = FindSkyLight();
|
|
if (!Light)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("No SkyLight found in scene"));
|
|
return false;
|
|
}
|
|
|
|
USkyLightComponent* LightComp = Light->GetLightComponent();
|
|
if (!LightComp) return false;
|
|
|
|
if (Params->HasField(TEXT("intensity")))
|
|
{
|
|
LightComp->SetIntensity(Params->GetNumberField(TEXT("intensity")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("color")))
|
|
{
|
|
FLinearColor Color = ParseHexColor(Params->GetStringField(TEXT("color")));
|
|
LightComp->SetLightColor(Color);
|
|
}
|
|
|
|
LightComp->MarkRenderStateDirty();
|
|
return true;
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetSkyLightParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
ASkyLight* Light = FindSkyLight();
|
|
if (!Light) return Result;
|
|
|
|
USkyLightComponent* LightComp = Light->GetLightComponent();
|
|
if (!LightComp) return Result;
|
|
|
|
Result->SetNumberField(TEXT("intensity"), LightComp->Intensity);
|
|
Result->SetStringField(TEXT("color"), ColorToHex(LightComp->GetLightColor()));
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Exponential Height Fog
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetFogParameters(const TSharedPtr<FJsonObject>& Params)
|
|
{
|
|
AExponentialHeightFog* Fog = FindExponentialHeightFog();
|
|
if (!Fog)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("No ExponentialHeightFog found in scene"));
|
|
return false;
|
|
}
|
|
|
|
UExponentialHeightFogComponent* FogComp = Fog->GetComponent();
|
|
if (!FogComp) return false;
|
|
|
|
if (Params->HasField(TEXT("enabled")))
|
|
{
|
|
FogComp->SetVisibility(Params->GetBoolField(TEXT("enabled")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("fog_density")))
|
|
{
|
|
FogComp->SetFogDensity(Params->GetNumberField(TEXT("fog_density")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("fog_height_falloff")))
|
|
{
|
|
FogComp->SetFogHeightFalloff(Params->GetNumberField(TEXT("fog_height_falloff")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("fog_inscattering_color")))
|
|
{
|
|
FLinearColor Color = ParseHexColor(Params->GetStringField(TEXT("fog_inscattering_color")));
|
|
FogComp->SetFogInscatteringColor(Color);
|
|
}
|
|
|
|
if (Params->HasField(TEXT("fog_max_opacity")))
|
|
{
|
|
FogComp->SetFogMaxOpacity(Params->GetNumberField(TEXT("fog_max_opacity")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("start_distance")))
|
|
{
|
|
FogComp->SetStartDistance(Params->GetNumberField(TEXT("start_distance")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("volumetric_fog")))
|
|
{
|
|
FogComp->SetVolumetricFog(Params->GetBoolField(TEXT("volumetric_fog")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("volumetric_fog_scattering_distribution")))
|
|
{
|
|
FogComp->VolumetricFogScatteringDistribution = Params->GetNumberField(TEXT("volumetric_fog_scattering_distribution"));
|
|
}
|
|
|
|
FogComp->MarkRenderStateDirty();
|
|
return true;
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetFogParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
AExponentialHeightFog* Fog = FindExponentialHeightFog();
|
|
if (!Fog) return Result;
|
|
|
|
UExponentialHeightFogComponent* FogComp = Fog->GetComponent();
|
|
if (!FogComp) return Result;
|
|
|
|
Result->SetBoolField(TEXT("enabled"), FogComp->IsVisible());
|
|
Result->SetNumberField(TEXT("fog_density"), FogComp->FogDensity);
|
|
Result->SetNumberField(TEXT("fog_height_falloff"), FogComp->FogHeightFalloff);
|
|
Result->SetNumberField(TEXT("fog_max_opacity"), FogComp->FogMaxOpacity);
|
|
Result->SetNumberField(TEXT("start_distance"), FogComp->StartDistance);
|
|
Result->SetBoolField(TEXT("volumetric_fog"), FogComp->bEnableVolumetricFog);
|
|
Result->SetNumberField(TEXT("volumetric_fog_scattering_distribution"), FogComp->VolumetricFogScatteringDistribution);
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Camera
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetCameraParameters(const TSharedPtr<FJsonObject>& Params)
|
|
{
|
|
ACineCameraActor* Camera = FindCineCamera();
|
|
if (!Camera)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("No CineCameraActor found in scene"));
|
|
return false;
|
|
}
|
|
|
|
UCineCameraComponent* CameraComp = Camera->GetCineCameraComponent();
|
|
if (!CameraComp) return false;
|
|
|
|
// Camera location
|
|
const TSharedPtr<FJsonObject>* LocationObj;
|
|
if (Params->TryGetObjectField(TEXT("location"), LocationObj))
|
|
{
|
|
FVector Location = Camera->GetActorLocation();
|
|
if ((*LocationObj)->HasField(TEXT("x"))) Location.X = (*LocationObj)->GetNumberField(TEXT("x"));
|
|
if ((*LocationObj)->HasField(TEXT("y"))) Location.Y = (*LocationObj)->GetNumberField(TEXT("y"));
|
|
if ((*LocationObj)->HasField(TEXT("z"))) Location.Z = (*LocationObj)->GetNumberField(TEXT("z"));
|
|
Camera->SetActorLocation(Location);
|
|
}
|
|
|
|
// Camera rotation
|
|
const TSharedPtr<FJsonObject>* RotationObj;
|
|
if (Params->TryGetObjectField(TEXT("rotation"), RotationObj))
|
|
{
|
|
FRotator Rotation = Camera->GetActorRotation();
|
|
if ((*RotationObj)->HasField(TEXT("pitch"))) Rotation.Pitch = (*RotationObj)->GetNumberField(TEXT("pitch"));
|
|
if ((*RotationObj)->HasField(TEXT("yaw"))) Rotation.Yaw = (*RotationObj)->GetNumberField(TEXT("yaw"));
|
|
if ((*RotationObj)->HasField(TEXT("roll"))) Rotation.Roll = (*RotationObj)->GetNumberField(TEXT("roll"));
|
|
Camera->SetActorRotation(Rotation);
|
|
}
|
|
|
|
if (Params->HasField(TEXT("focal_length")))
|
|
{
|
|
CameraComp->SetCurrentFocalLength(Params->GetNumberField(TEXT("focal_length")));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("aperture")))
|
|
{
|
|
CameraComp->CurrentAperture = Params->GetNumberField(TEXT("aperture"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("focus_distance")))
|
|
{
|
|
CameraComp->FocusSettings.ManualFocusDistance = Params->GetNumberField(TEXT("focus_distance"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("dof_enabled")))
|
|
{
|
|
CameraComp->PostProcessSettings.bOverride_DepthOfFieldFstop = Params->GetBoolField(TEXT("dof_enabled"));
|
|
}
|
|
|
|
if (Params->HasField(TEXT("motion_blur_amount")))
|
|
{
|
|
CameraComp->PostProcessSettings.bOverride_MotionBlurAmount = true;
|
|
CameraComp->PostProcessSettings.MotionBlurAmount = Params->GetNumberField(TEXT("motion_blur_amount"));
|
|
}
|
|
|
|
CameraComp->MarkRenderStateDirty();
|
|
return true;
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetCameraParameters()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
ACineCameraActor* Camera = FindCineCamera();
|
|
if (!Camera) return Result;
|
|
|
|
UCineCameraComponent* CameraComp = Camera->GetCineCameraComponent();
|
|
if (!CameraComp) return Result;
|
|
|
|
Result->SetNumberField(TEXT("focal_length"), CameraComp->CurrentFocalLength);
|
|
Result->SetNumberField(TEXT("aperture"), CameraComp->CurrentAperture);
|
|
Result->SetNumberField(TEXT("focus_distance"), CameraComp->FocusSettings.ManualFocusDistance);
|
|
Result->SetNumberField(TEXT("motion_blur_amount"), CameraComp->PostProcessSettings.MotionBlurAmount);
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Render Quality
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SetRenderQuality(const TSharedPtr<FJsonObject>& Settings)
|
|
{
|
|
// This would typically use console commands or project settings
|
|
// For now, we'll log what we would set
|
|
|
|
if (Settings->HasField(TEXT("lumen_quality")))
|
|
{
|
|
float Quality = Settings->GetNumberField(TEXT("lumen_quality"));
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("Would set Lumen quality to: %f"), Quality);
|
|
// r.Lumen.ScreenTracing.MaxIterations, etc.
|
|
}
|
|
|
|
if (Settings->HasField(TEXT("shadow_quality")))
|
|
{
|
|
FString Quality = Settings->GetStringField(TEXT("shadow_quality"));
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("Would set shadow quality to: %s"), *Quality);
|
|
// sg.ShadowQuality
|
|
}
|
|
|
|
if (Settings->HasField(TEXT("resolution_scale")))
|
|
{
|
|
float Scale = Settings->GetNumberField(TEXT("resolution_scale"));
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("Would set resolution scale to: %f"), Scale);
|
|
// r.ScreenPercentage
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Asset Search
|
|
// ============================================================================
|
|
|
|
TArray<TSharedPtr<FJsonValue>> URalphaParameterBridge::SearchAssets(const FString& Query, const FString& AssetType, int32 MaxResults)
|
|
{
|
|
TArray<TSharedPtr<FJsonValue>> Results;
|
|
|
|
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
|
|
IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
|
|
|
|
FARFilter Filter;
|
|
Filter.bRecursivePaths = true;
|
|
Filter.PackagePaths.Add(TEXT("/Game"));
|
|
|
|
if (AssetType == TEXT("StaticMesh"))
|
|
{
|
|
Filter.ClassPaths.Add(UStaticMesh::StaticClass()->GetClassPathName());
|
|
}
|
|
// Add more type filters as needed
|
|
|
|
TArray<FAssetData> AssetList;
|
|
AssetRegistry.GetAssets(Filter, AssetList);
|
|
|
|
int32 Count = 0;
|
|
for (const FAssetData& Asset : AssetList)
|
|
{
|
|
if (Count >= MaxResults) break;
|
|
|
|
FString AssetName = Asset.AssetName.ToString();
|
|
if (AssetName.Contains(Query, ESearchCase::IgnoreCase))
|
|
{
|
|
TSharedPtr<FJsonObject> AssetObj = MakeShared<FJsonObject>();
|
|
AssetObj->SetStringField(TEXT("name"), AssetName);
|
|
AssetObj->SetStringField(TEXT("asset_path"), Asset.GetObjectPathString());
|
|
AssetObj->SetStringField(TEXT("class"), Asset.AssetClassPath.GetAssetName().ToString());
|
|
|
|
Results.Add(MakeShared<FJsonValueObject>(AssetObj));
|
|
Count++;
|
|
}
|
|
}
|
|
|
|
return Results;
|
|
}
|
|
|
|
TArray<TSharedPtr<FJsonValue>> URalphaParameterBridge::ListAssets(const FString& FolderPath, const FString& AssetType, bool bRecursive)
|
|
{
|
|
TArray<TSharedPtr<FJsonValue>> Results;
|
|
|
|
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
|
|
IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
|
|
|
|
FARFilter Filter;
|
|
Filter.bRecursivePaths = bRecursive;
|
|
Filter.PackagePaths.Add(*FolderPath);
|
|
|
|
TArray<FAssetData> AssetList;
|
|
AssetRegistry.GetAssets(Filter, AssetList);
|
|
|
|
for (const FAssetData& Asset : AssetList)
|
|
{
|
|
TSharedPtr<FJsonObject> AssetObj = MakeShared<FJsonObject>();
|
|
AssetObj->SetStringField(TEXT("name"), Asset.AssetName.ToString());
|
|
AssetObj->SetStringField(TEXT("asset_path"), Asset.GetObjectPathString());
|
|
AssetObj->SetStringField(TEXT("class"), Asset.AssetClassPath.GetAssetName().ToString());
|
|
|
|
Results.Add(MakeShared<FJsonValueObject>(AssetObj));
|
|
}
|
|
|
|
return Results;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Actor Management
|
|
// ============================================================================
|
|
|
|
bool URalphaParameterBridge::SpawnActor(const FString& AssetPath, const FVector& Location, const FRotator& Rotation, float Scale, const FString& ActorLabel, FString& OutActorId)
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return false;
|
|
|
|
// Load the asset
|
|
UObject* LoadedAsset = StaticLoadObject(UStaticMesh::StaticClass(), nullptr, *AssetPath);
|
|
UStaticMesh* StaticMesh = Cast<UStaticMesh>(LoadedAsset);
|
|
|
|
if (!StaticMesh)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("Failed to load static mesh: %s"), *AssetPath);
|
|
return false;
|
|
}
|
|
|
|
// Spawn the actor
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
|
|
AStaticMeshActor* NewActor = World->SpawnActor<AStaticMeshActor>(Location, Rotation, SpawnParams);
|
|
if (!NewActor)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("Failed to spawn actor"));
|
|
return false;
|
|
}
|
|
|
|
NewActor->GetStaticMeshComponent()->SetStaticMesh(StaticMesh);
|
|
NewActor->SetActorScale3D(FVector(Scale));
|
|
|
|
#if WITH_EDITOR
|
|
if (!ActorLabel.IsEmpty())
|
|
{
|
|
NewActor->SetActorLabel(ActorLabel);
|
|
}
|
|
#endif
|
|
|
|
OutActorId = NewActor->GetName();
|
|
return true;
|
|
}
|
|
|
|
bool URalphaParameterBridge::DeleteActor(const FString& ActorId)
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return false;
|
|
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
if (It->GetName() == ActorId)
|
|
{
|
|
World->DestroyActor(*It);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool URalphaParameterBridge::SetActorMaterial(const FString& ActorId, const FString& MaterialPath, int32 MaterialIndex)
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return false;
|
|
|
|
// Find the actor
|
|
AActor* TargetActor = nullptr;
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
if (It->GetName() == ActorId)
|
|
{
|
|
TargetActor = *It;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!TargetActor)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorMaterial: Actor not found: %s"), *ActorId);
|
|
return false;
|
|
}
|
|
|
|
// Load the material
|
|
UMaterialInterface* Material = Cast<UMaterialInterface>(StaticLoadObject(UMaterialInterface::StaticClass(), nullptr, *MaterialPath));
|
|
if (!Material)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorMaterial: Failed to load material: %s"), *MaterialPath);
|
|
return false;
|
|
}
|
|
|
|
// Try to find a mesh component to apply the material to
|
|
AStaticMeshActor* MeshActor = Cast<AStaticMeshActor>(TargetActor);
|
|
if (MeshActor && MeshActor->GetStaticMeshComponent())
|
|
{
|
|
MeshActor->GetStaticMeshComponent()->SetMaterial(MaterialIndex, Material);
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("SetActorMaterial: Applied material %s to %s"), *MaterialPath, *ActorId);
|
|
return true;
|
|
}
|
|
|
|
// Try generic primitive component
|
|
UPrimitiveComponent* PrimComp = TargetActor->FindComponentByClass<UPrimitiveComponent>();
|
|
if (PrimComp)
|
|
{
|
|
PrimComp->SetMaterial(MaterialIndex, Material);
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("SetActorMaterial: Applied material %s to %s (primitive)"), *MaterialPath, *ActorId);
|
|
return true;
|
|
}
|
|
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorMaterial: No suitable component found on %s"), *ActorId);
|
|
return false;
|
|
}
|
|
|
|
bool URalphaParameterBridge::SetActorSimpleMaterial(const FString& ActorId, const FLinearColor& BaseColor, float Metallic, float Roughness, float Opacity)
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return false;
|
|
|
|
// Find the actor
|
|
AActor* TargetActor = nullptr;
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
if (It->GetName() == ActorId)
|
|
{
|
|
TargetActor = *It;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!TargetActor)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorSimpleMaterial: Actor not found: %s"), *ActorId);
|
|
return false;
|
|
}
|
|
|
|
// Load the basic material from engine content - M_Basic_Wall is a simple material that supports our parameters
|
|
UMaterialInterface* BaseMaterial = Cast<UMaterialInterface>(StaticLoadObject(UMaterialInterface::StaticClass(), nullptr, TEXT("/Engine/BasicShapes/BasicShapeMaterial.BasicShapeMaterial")));
|
|
if (!BaseMaterial)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorSimpleMaterial: Failed to load base material"));
|
|
return false;
|
|
}
|
|
|
|
// Create a dynamic material instance
|
|
UMaterialInstanceDynamic* DynMaterial = UMaterialInstanceDynamic::Create(BaseMaterial, TargetActor);
|
|
if (!DynMaterial)
|
|
{
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorSimpleMaterial: Failed to create dynamic material"));
|
|
return false;
|
|
}
|
|
|
|
// Set material parameters - BasicShapeMaterial uses specific parameter names
|
|
// Try common parameter names for base color
|
|
DynMaterial->SetVectorParameterValue(TEXT("Color"), BaseColor);
|
|
DynMaterial->SetVectorParameterValue(TEXT("BaseColor"), BaseColor);
|
|
DynMaterial->SetVectorParameterValue(TEXT("Base Color"), BaseColor);
|
|
|
|
// Try common scalar parameters
|
|
DynMaterial->SetScalarParameterValue(TEXT("Metallic"), Metallic);
|
|
DynMaterial->SetScalarParameterValue(TEXT("Roughness"), Roughness);
|
|
DynMaterial->SetScalarParameterValue(TEXT("Opacity"), Opacity);
|
|
|
|
// Apply to the actor's mesh component
|
|
AStaticMeshActor* MeshActor = Cast<AStaticMeshActor>(TargetActor);
|
|
if (MeshActor && MeshActor->GetStaticMeshComponent())
|
|
{
|
|
MeshActor->GetStaticMeshComponent()->SetMaterial(0, DynMaterial);
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("SetActorSimpleMaterial: Applied dynamic material to %s (Color: R=%.2f G=%.2f B=%.2f, Metallic=%.2f, Roughness=%.2f)"),
|
|
*ActorId, BaseColor.R, BaseColor.G, BaseColor.B, Metallic, Roughness);
|
|
return true;
|
|
}
|
|
|
|
// Try generic primitive component
|
|
UPrimitiveComponent* PrimComp = TargetActor->FindComponentByClass<UPrimitiveComponent>();
|
|
if (PrimComp)
|
|
{
|
|
PrimComp->SetMaterial(0, DynMaterial);
|
|
UE_LOG(LogRalphaMCP, Log, TEXT("SetActorSimpleMaterial: Applied dynamic material to %s (primitive)"), *ActorId);
|
|
return true;
|
|
}
|
|
|
|
UE_LOG(LogRalphaMCP, Warning, TEXT("SetActorSimpleMaterial: No suitable component found on %s"), *ActorId);
|
|
return false;
|
|
}
|
|
|
|
TArray<TSharedPtr<FJsonValue>> URalphaParameterBridge::ListActors(const FString& ClassFilter, const FString& NameFilter, bool bIncludeTransforms)
|
|
{
|
|
TArray<TSharedPtr<FJsonValue>> Results;
|
|
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return Results;
|
|
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
AActor* Actor = *It;
|
|
|
|
// Apply filters
|
|
if (!ClassFilter.IsEmpty() && !Actor->GetClass()->GetName().Contains(ClassFilter))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (!NameFilter.IsEmpty() && !Actor->GetActorLabel().Contains(NameFilter))
|
|
{
|
|
continue;
|
|
}
|
|
#else
|
|
if (!NameFilter.IsEmpty() && !Actor->GetName().Contains(NameFilter))
|
|
{
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
TSharedPtr<FJsonObject> ActorObj = MakeShared<FJsonObject>();
|
|
ActorObj->SetStringField(TEXT("actor_id"), Actor->GetName());
|
|
#if WITH_EDITOR
|
|
ActorObj->SetStringField(TEXT("label"), Actor->GetActorLabel());
|
|
#else
|
|
ActorObj->SetStringField(TEXT("label"), Actor->GetName());
|
|
#endif
|
|
ActorObj->SetStringField(TEXT("class"), Actor->GetClass()->GetName());
|
|
|
|
if (bIncludeTransforms)
|
|
{
|
|
FVector Location = Actor->GetActorLocation();
|
|
FRotator Rotation = Actor->GetActorRotation();
|
|
FVector Scale = Actor->GetActorScale3D();
|
|
|
|
TSharedPtr<FJsonObject> TransformObj = MakeShared<FJsonObject>();
|
|
|
|
TSharedPtr<FJsonObject> LocObj = MakeShared<FJsonObject>();
|
|
LocObj->SetNumberField(TEXT("x"), Location.X);
|
|
LocObj->SetNumberField(TEXT("y"), Location.Y);
|
|
LocObj->SetNumberField(TEXT("z"), Location.Z);
|
|
TransformObj->SetObjectField(TEXT("location"), LocObj);
|
|
|
|
TSharedPtr<FJsonObject> RotObj = MakeShared<FJsonObject>();
|
|
RotObj->SetNumberField(TEXT("pitch"), Rotation.Pitch);
|
|
RotObj->SetNumberField(TEXT("yaw"), Rotation.Yaw);
|
|
RotObj->SetNumberField(TEXT("roll"), Rotation.Roll);
|
|
TransformObj->SetObjectField(TEXT("rotation"), RotObj);
|
|
|
|
TSharedPtr<FJsonObject> ScaleObj = MakeShared<FJsonObject>();
|
|
ScaleObj->SetNumberField(TEXT("x"), Scale.X);
|
|
ScaleObj->SetNumberField(TEXT("y"), Scale.Y);
|
|
ScaleObj->SetNumberField(TEXT("z"), Scale.Z);
|
|
TransformObj->SetObjectField(TEXT("scale"), ScaleObj);
|
|
|
|
ActorObj->SetObjectField(TEXT("transform"), TransformObj);
|
|
}
|
|
|
|
Results.Add(MakeShared<FJsonValueObject>(ActorObj));
|
|
}
|
|
|
|
return Results;
|
|
}
|
|
|
|
bool URalphaParameterBridge::SetActorTransform(const FString& ActorId, const FVector* Location, const FRotator* Rotation, const float* Scale, bool bRelative)
|
|
{
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return false;
|
|
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
if (It->GetName() == ActorId)
|
|
{
|
|
AActor* Actor = *It;
|
|
|
|
if (Location)
|
|
{
|
|
if (bRelative)
|
|
{
|
|
Actor->SetActorLocation(Actor->GetActorLocation() + *Location);
|
|
}
|
|
else
|
|
{
|
|
Actor->SetActorLocation(*Location);
|
|
}
|
|
}
|
|
|
|
if (Rotation)
|
|
{
|
|
if (bRelative)
|
|
{
|
|
Actor->SetActorRotation(Actor->GetActorRotation() + *Rotation);
|
|
}
|
|
else
|
|
{
|
|
Actor->SetActorRotation(*Rotation);
|
|
}
|
|
}
|
|
|
|
if (Scale)
|
|
{
|
|
Actor->SetActorScale3D(FVector(*Scale));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::GetActorDetails(const FString& ActorId, bool bIncludeComponents, bool bIncludeMaterials)
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World) return Result;
|
|
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
|
{
|
|
if (It->GetName() == ActorId)
|
|
{
|
|
AActor* Actor = *It;
|
|
|
|
Result->SetStringField(TEXT("actor_id"), Actor->GetName());
|
|
#if WITH_EDITOR
|
|
Result->SetStringField(TEXT("label"), Actor->GetActorLabel());
|
|
#else
|
|
Result->SetStringField(TEXT("label"), Actor->GetName());
|
|
#endif
|
|
Result->SetStringField(TEXT("class"), Actor->GetClass()->GetName());
|
|
|
|
// Transform
|
|
FVector Location = Actor->GetActorLocation();
|
|
FRotator Rotation = Actor->GetActorRotation();
|
|
FVector Scale = Actor->GetActorScale3D();
|
|
|
|
TSharedPtr<FJsonObject> TransformObj = MakeShared<FJsonObject>();
|
|
TSharedPtr<FJsonObject> LocObj = MakeShared<FJsonObject>();
|
|
LocObj->SetNumberField(TEXT("x"), Location.X);
|
|
LocObj->SetNumberField(TEXT("y"), Location.Y);
|
|
LocObj->SetNumberField(TEXT("z"), Location.Z);
|
|
TransformObj->SetObjectField(TEXT("location"), LocObj);
|
|
|
|
TSharedPtr<FJsonObject> RotObj = MakeShared<FJsonObject>();
|
|
RotObj->SetNumberField(TEXT("pitch"), Rotation.Pitch);
|
|
RotObj->SetNumberField(TEXT("yaw"), Rotation.Yaw);
|
|
RotObj->SetNumberField(TEXT("roll"), Rotation.Roll);
|
|
TransformObj->SetObjectField(TEXT("rotation"), RotObj);
|
|
|
|
Result->SetObjectField(TEXT("transform"), TransformObj);
|
|
|
|
if (bIncludeComponents)
|
|
{
|
|
TArray<TSharedPtr<FJsonValue>> ComponentsArray;
|
|
TArray<UActorComponent*> Components;
|
|
Actor->GetComponents(Components);
|
|
|
|
for (UActorComponent* Component : Components)
|
|
{
|
|
TSharedPtr<FJsonObject> CompObj = MakeShared<FJsonObject>();
|
|
CompObj->SetStringField(TEXT("name"), Component->GetName());
|
|
CompObj->SetStringField(TEXT("class"), Component->GetClass()->GetName());
|
|
ComponentsArray.Add(MakeShared<FJsonValueObject>(CompObj));
|
|
}
|
|
|
|
Result->SetArrayField(TEXT("components"), ComponentsArray);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Scene Setup
|
|
// ============================================================================
|
|
|
|
TSharedPtr<FJsonObject> URalphaParameterBridge::SetupScene()
|
|
{
|
|
TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
|
|
TArray<FString> CreatedActors;
|
|
TArray<FString> ExistingActors;
|
|
|
|
UWorld* World = GetCurrentWorld();
|
|
if (!World)
|
|
{
|
|
Result->SetBoolField(TEXT("success"), false);
|
|
Result->SetStringField(TEXT("error"), TEXT("No world available"));
|
|
return Result;
|
|
}
|
|
|
|
// Check/Create PostProcessVolume
|
|
if (!FindPostProcessVolume())
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
APostProcessVolume* PPV = World->SpawnActor<APostProcessVolume>(FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
|
|
if (PPV)
|
|
{
|
|
PPV->bUnbound = true;
|
|
PPV->Settings.bOverride_AutoExposureBias = true;
|
|
PPV->Settings.AutoExposureBias = 0.0f;
|
|
#if WITH_EDITOR
|
|
PPV->SetActorLabel(TEXT("Ralpha_PostProcess"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("PostProcessVolume"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("PostProcessVolume"));
|
|
}
|
|
|
|
// Check/Create DirectionalLight
|
|
if (!FindDirectionalLight())
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
ADirectionalLight* Light = World->SpawnActor<ADirectionalLight>(FVector::ZeroVector, FRotator(-45.0f, 0.0f, 0.0f), SpawnParams);
|
|
if (Light)
|
|
{
|
|
#if WITH_EDITOR
|
|
Light->SetActorLabel(TEXT("Ralpha_Sun"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("DirectionalLight"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("DirectionalLight"));
|
|
}
|
|
|
|
// Check/Create SkyLight
|
|
if (!FindSkyLight())
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
ASkyLight* Light = World->SpawnActor<ASkyLight>(FVector(0.0f, 0.0f, 1000.0f), FRotator::ZeroRotator, SpawnParams);
|
|
if (Light)
|
|
{
|
|
#if WITH_EDITOR
|
|
Light->SetActorLabel(TEXT("Ralpha_SkyLight"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("SkyLight"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("SkyLight"));
|
|
}
|
|
|
|
// Check/Create ExponentialHeightFog
|
|
if (!FindExponentialHeightFog())
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
AExponentialHeightFog* Fog = World->SpawnActor<AExponentialHeightFog>(FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
|
|
if (Fog)
|
|
{
|
|
#if WITH_EDITOR
|
|
Fog->SetActorLabel(TEXT("Ralpha_Fog"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("ExponentialHeightFog"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("ExponentialHeightFog"));
|
|
}
|
|
|
|
// Check/Create Sky Atmosphere (physically-based sky)
|
|
bool bHasSkyAtmosphere = false;
|
|
for (TActorIterator<ASkyAtmosphere> It(World); It; ++It)
|
|
{
|
|
bHasSkyAtmosphere = true;
|
|
break;
|
|
}
|
|
if (!bHasSkyAtmosphere)
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
ASkyAtmosphere* SkyAtmo = World->SpawnActor<ASkyAtmosphere>(FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
|
|
if (SkyAtmo)
|
|
{
|
|
#if WITH_EDITOR
|
|
SkyAtmo->SetActorLabel(TEXT("Ralpha_SkyAtmosphere"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("SkyAtmosphere"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("SkyAtmosphere"));
|
|
}
|
|
|
|
// Check/Create Volumetric Cloud
|
|
bool bHasVolumetricCloud = false;
|
|
for (TActorIterator<AVolumetricCloud> It(World); It; ++It)
|
|
{
|
|
bHasVolumetricCloud = true;
|
|
break;
|
|
}
|
|
if (!bHasVolumetricCloud)
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
AVolumetricCloud* Cloud = World->SpawnActor<AVolumetricCloud>(FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
|
|
if (Cloud)
|
|
{
|
|
#if WITH_EDITOR
|
|
Cloud->SetActorLabel(TEXT("Ralpha_VolumetricCloud"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("VolumetricCloud"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("VolumetricCloud"));
|
|
}
|
|
|
|
// Check/Create CineCameraActor
|
|
if (!FindCineCamera())
|
|
{
|
|
FActorSpawnParameters SpawnParams;
|
|
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
|
|
ACineCameraActor* Camera = World->SpawnActor<ACineCameraActor>(FVector(0.0f, -500.0f, 200.0f), FRotator(0.0f, 90.0f, 0.0f), SpawnParams);
|
|
if (Camera)
|
|
{
|
|
#if WITH_EDITOR
|
|
Camera->SetActorLabel(TEXT("Ralpha_Camera"));
|
|
#endif
|
|
CreatedActors.Add(TEXT("CineCameraActor"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExistingActors.Add(TEXT("CineCameraActor"));
|
|
}
|
|
|
|
Result->SetBoolField(TEXT("success"), true);
|
|
|
|
TArray<TSharedPtr<FJsonValue>> CreatedArray;
|
|
for (const FString& Actor : CreatedActors)
|
|
{
|
|
CreatedArray.Add(MakeShared<FJsonValueString>(Actor));
|
|
}
|
|
Result->SetArrayField(TEXT("created"), CreatedArray);
|
|
|
|
TArray<TSharedPtr<FJsonValue>> ExistingArray;
|
|
for (const FString& Actor : ExistingActors)
|
|
{
|
|
ExistingArray.Add(MakeShared<FJsonValueString>(Actor));
|
|
}
|
|
Result->SetArrayField(TEXT("existing"), ExistingArray);
|
|
|
|
return Result;
|
|
}
|