Fr0zkaandClaude Opus 5.5
d696463c68
Luna, integration round 4 (owner requirement: Core must know every strate type). Coverage, Core vs legacy owner field (one probe per type, 686,000 LOD0 samples): TunnelNetwork approximate (2.17% signs differ); FlatPlain / CrystalChamber native slab fields missing (generic cave, 1.28%); Maze missing (13.3%); VerticalShafts missing (no shaft surface); FloatingIslands missing (95.8%); Underwater approximate + no water. SurfaceWorld: exact density (0 sign changes, LOD0-3 hashes match) through the copied legacy evaluator -- but at legacy cost: full view 23.1 s vs legacy 23.9 s (Core caves without surface 0.785 s). Passages: SlopedTunnel/VerticalShaft/Spiral pass walkability; Cascading (365/1,495) and Worm (109/1,490) FAIL. Transitions approximate (1.2-1.3%). BuildHost UBT + actor validation pass (SurfaceWorld layout: 2,553 visual keys, 448 LOD transitions, biome query). Small owner/Core capture pairs in core_strate_coverage/. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MmSoF64BbRFmk9C3p1VsBJ
386 lines
20 KiB
C++
386 lines
20 KiB
C++
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Json.h"
|
|
#include "VoxelBiomeDefinition.h"
|
|
#include "VoxelGenerator.h"
|
|
#include "VoxelSettings.h"
|
|
#include "VoxelStrateDefinition.h"
|
|
#include "VoxelStrateManager.h"
|
|
#include "VoxelTerrainOpDefinition.h"
|
|
|
|
struct FStandaloneParitySample
|
|
{
|
|
FVector PositionVoxels;
|
|
float PluginDensity = 0.0f;
|
|
std::string Kind;
|
|
int32 StrateIndex = INDEX_NONE;
|
|
};
|
|
|
|
struct FStandaloneOwnerWorld
|
|
{
|
|
std::unique_ptr<UVoxelSettings> Settings;
|
|
std::unique_ptr<UVoxelStrateManager> Manager;
|
|
std::unique_ptr<UVoxelGenerator> Generator;
|
|
std::vector<std::unique_ptr<UVoxelStrateDefinition>> DefinitionStorage;
|
|
std::vector<std::unique_ptr<UVoxelBiomeDefinition>> BiomeStorage;
|
|
std::vector<std::unique_ptr<UVoxelTerrainOpDefinition>> OperationStorage;
|
|
std::vector<FStandaloneParitySample> DensitySamples;
|
|
FVector ViewerStartVoxels = FVector::ZeroVector;
|
|
bool ViewerStartFound = false;
|
|
int32 Seed = 0;
|
|
int32 ClipRadius = 6;
|
|
int32 MaxClipLevel = 8;
|
|
int32 FullResClipLevels = 2;
|
|
int32 CoarseTileCells = 16;
|
|
int32 RenderDistanceChunks = 1536;
|
|
int32 StrateContentCutMinLevel = 9;
|
|
bool bGenerateSkirts = true;
|
|
int32 SkirtCells = 2;
|
|
int32 LODOctaveDrop = 0;
|
|
};
|
|
|
|
namespace StandaloneOwnerLoader
|
|
{
|
|
template<class T>
|
|
inline void ReadField(const VFJson::Value& Object, const char* Name, T& Out)
|
|
{
|
|
const VFJson::Value& Value = Object.Get(Name);
|
|
if constexpr (std::is_same_v<T, bool>)
|
|
{
|
|
if (std::holds_alternative<bool>(Value.Data)) Out = Value.Boolean(Out);
|
|
else if (Value.IsNumber()) Out = Value.Number() != 0.0;
|
|
}
|
|
else if constexpr (std::is_enum_v<T>)
|
|
{
|
|
if (Value.IsNumber()) Out = static_cast<T>(Value.Integer());
|
|
}
|
|
else if constexpr (std::is_arithmetic_v<T>)
|
|
{
|
|
if (Value.IsNumber()) Out = static_cast<T>(Value.Number());
|
|
}
|
|
}
|
|
|
|
inline void ReadText(const VFJson::Value& Object, const char* Name, FText& Out)
|
|
{
|
|
const VFJson::Value& Value = Object.Get(Name);
|
|
if (Value.IsString()) Out = FText::FromString(FString(Value.String()));
|
|
}
|
|
|
|
inline void ReadLinearColor(const VFJson::Value& Object, FLinearColor& Out)
|
|
{
|
|
ReadField(Object, "R", Out.R); ReadField(Object, "G", Out.G);
|
|
ReadField(Object, "B", Out.B); ReadField(Object, "A", Out.A);
|
|
}
|
|
|
|
inline void ReadVector(const VFJson::Value& Object, FVector& Out)
|
|
{
|
|
ReadField(Object, "x", Out.X); ReadField(Object, "y", Out.Y); ReadField(Object, "z", Out.Z);
|
|
}
|
|
|
|
inline void ReadGenerationParams(const VFJson::Value& J, FStrateGenerationParams& P)
|
|
{
|
|
#define VF_LOAD_STRATE_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_STRATE_PARAM_FIELDS(VF_LOAD_STRATE_FIELD, VF_LOAD_STRATE_FIELD)
|
|
#undef VF_LOAD_STRATE_FIELD
|
|
ReadField(J, "bTunnelFloorEnabled", P.bTunnelFloorEnabled);
|
|
}
|
|
|
|
inline void ReadDisturbances(const VFJson::Value& J, FStrateDisturbanceParams& P)
|
|
{
|
|
ReadField(J,"ChasmDensity",P.ChasmDensity); ReadField(J,"ChasmSpacing",P.ChasmSpacing);
|
|
ReadField(J,"ChasmRadius",P.ChasmRadius); ReadField(J,"BridgeDensity",P.BridgeDensity);
|
|
ReadField(J,"BridgeSpacing",P.BridgeSpacing); ReadField(J,"BridgeRadius",P.BridgeRadius);
|
|
ReadField(J,"RidgeDensity",P.RidgeDensity); ReadField(J,"RidgeSpacing",P.RidgeSpacing);
|
|
ReadField(J,"RidgeHeight",P.RidgeHeight); ReadField(J,"RidgeThickness",P.RidgeThickness);
|
|
ReadField(J,"BaseDensity",P.BaseDensity); ReadField(J,"BoundarySealThickness",P.BoundarySealThickness);
|
|
}
|
|
|
|
inline void ReadPassageConfig(const VFJson::Value& J, FStratePassageConfig& P)
|
|
{
|
|
ReadField(J,"Connections",P.Connections); ReadField(J,"Style",P.Style);
|
|
ReadField(J,"MouthRadius",P.MouthRadius); ReadField(J,"MidRadius",P.MidRadius);
|
|
ReadField(J,"ReachMin",P.ReachMin); ReadField(J,"ReachMax",P.ReachMax);
|
|
ReadField(J,"DistanceMin",P.DistanceMin); ReadField(J,"DistanceMax",P.DistanceMax);
|
|
ReadField(J,"Wander",P.Wander); ReadField(J,"Segments",P.Segments);
|
|
ReadField(J,"VerticalWobble",P.VerticalWobble); ReadField(J,"SpiralRadius",P.SpiralRadius);
|
|
ReadField(J,"SpiralTurns",P.SpiralTurns); ReadField(J,"CascadeSteps",P.CascadeSteps);
|
|
ReadField(J,"CascadeLedge",P.CascadeLedge);
|
|
}
|
|
|
|
inline void ReadSurfaceParams(const VFJson::Value& J, FSurfaceGenerationParams& P)
|
|
{
|
|
#define VF_SURFACE_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_SURFACE_FIELD(BaseGroundRelative) VF_SURFACE_FIELD(ElevationRange)
|
|
VF_SURFACE_FIELD(ContinentFrequency) VF_SURFACE_FIELD(MountainStrength)
|
|
VF_SURFACE_FIELD(MountainFrequency) VF_SURFACE_FIELD(DetailFrequency)
|
|
VF_SURFACE_FIELD(SurfaceRoughness) VF_SURFACE_FIELD(HeightWarpStrength)
|
|
VF_SURFACE_FIELD(HeightWarpFrequency) VF_SURFACE_FIELD(ReliefFrequency)
|
|
VF_SURFACE_FIELD(ReliefStrength) VF_SURFACE_FIELD(ReliefContrast)
|
|
VF_SURFACE_FIELD(TerraceStrength) VF_SURFACE_FIELD(TerraceHeight)
|
|
VF_SURFACE_FIELD(TerraceHardness) VF_SURFACE_FIELD(LayerLineDepth)
|
|
VF_SURFACE_FIELD(LayerLineSpacing) VF_SURFACE_FIELD(CliffStrength)
|
|
VF_SURFACE_FIELD(CliffSlopeThreshold) VF_SURFACE_FIELD(CliffSharpness)
|
|
VF_SURFACE_FIELD(CliffSampleDist) VF_SURFACE_FIELD(OverhangStrength)
|
|
VF_SURFACE_FIELD(OverhangReach) VF_SURFACE_FIELD(OverhangHeight)
|
|
VF_SURFACE_FIELD(OverhangFrequency) VF_SURFACE_FIELD(OverhangZScale)
|
|
VF_SURFACE_FIELD(OverhangSlopeThreshold) VF_SURFACE_FIELD(WaterLevelRelative)
|
|
VF_SURFACE_FIELD(BeachWidth) VF_SURFACE_FIELD(CeilingRelative)
|
|
VF_SURFACE_FIELD(CeilingRoughness) VF_SURFACE_FIELD(CeilingRoughnessFrequency)
|
|
VF_SURFACE_FIELD(CeilingUndulation) VF_SURFACE_FIELD(CeilingUndulationFrequency)
|
|
VF_SURFACE_FIELD(CeilingRidgeStrength) VF_SURFACE_FIELD(CeilingRidgeFrequency)
|
|
VF_SURFACE_FIELD(CeilingWarpStrength) VF_SURFACE_FIELD(CeilingWarpFrequency)
|
|
VF_SURFACE_FIELD(BoundarySealThickness) VF_SURFACE_FIELD(BaseDensity)
|
|
#undef VF_SURFACE_FIELD
|
|
}
|
|
|
|
inline void ReadSlabParams(const VFJson::Value& J, FSlabGenerationParams& P)
|
|
{
|
|
#define VF_SLAB_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_SLAB_FIELD(FloorRelativeHeight) VF_SLAB_FIELD(CeilingRelativeHeight)
|
|
VF_SLAB_FIELD(FloorRoughness) VF_SLAB_FIELD(FloorRoughnessFrequency)
|
|
VF_SLAB_FIELD(CeilingRoughness) VF_SLAB_FIELD(CeilingRoughnessFrequency)
|
|
VF_SLAB_FIELD(ColumnDensity) VF_SLAB_FIELD(ColumnMinRadius)
|
|
VF_SLAB_FIELD(ColumnMaxRadius) VF_SLAB_FIELD(ColumnSpacing)
|
|
VF_SLAB_FIELD(BoundarySealThickness) VF_SLAB_FIELD(BaseDensity)
|
|
#undef VF_SLAB_FIELD
|
|
}
|
|
|
|
inline void ReadMazeParams(const VFJson::Value& J, FMazeGenerationParams& P)
|
|
{
|
|
#define VF_MAZE_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_MAZE_FIELD(CellSize) VF_MAZE_FIELD(CorridorRadius)
|
|
VF_MAZE_FIELD(BranchProbability) VF_MAZE_FIELD(Verticality)
|
|
VF_MAZE_FIELD(SurfaceRoughness) VF_MAZE_FIELD(BoundarySealThickness)
|
|
VF_MAZE_FIELD(BaseDensity)
|
|
#undef VF_MAZE_FIELD
|
|
}
|
|
|
|
inline void ReadVerticalShaftParams(const VFJson::Value& J, FVerticalShaftParams& P)
|
|
{
|
|
#define VF_SHAFT_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_SHAFT_FIELD(ShaftSpacing) VF_SHAFT_FIELD(ShaftDensity)
|
|
VF_SHAFT_FIELD(ShaftMinRadius) VF_SHAFT_FIELD(ShaftMaxRadius)
|
|
VF_SHAFT_FIELD(CrossConnectChance) VF_SHAFT_FIELD(ConnectorRadius)
|
|
VF_SHAFT_FIELD(LedgeSpacing) VF_SHAFT_FIELD(LedgeDepth)
|
|
VF_SHAFT_FIELD(SurfaceRoughness) VF_SHAFT_FIELD(BoundarySealThickness)
|
|
VF_SHAFT_FIELD(BaseDensity)
|
|
#undef VF_SHAFT_FIELD
|
|
}
|
|
|
|
inline void ReadFloatingIslandParams(const VFJson::Value& J, FFloatingIslandParams& P)
|
|
{
|
|
#define VF_ISLAND_FIELD(Name) ReadField(J, #Name, P.Name);
|
|
VF_ISLAND_FIELD(IslandSpacing) VF_ISLAND_FIELD(IslandDensity)
|
|
VF_ISLAND_FIELD(IslandMinRadius) VF_ISLAND_FIELD(IslandMaxRadius)
|
|
VF_ISLAND_FIELD(ThicknessRatio) VF_ISLAND_FIELD(VerticalJitter)
|
|
VF_ISLAND_FIELD(TopFlatten) VF_ISLAND_FIELD(SurfaceRoughness)
|
|
VF_ISLAND_FIELD(SDFBlendRadius) VF_ISLAND_FIELD(BoundarySealThickness)
|
|
VF_ISLAND_FIELD(BaseDensity)
|
|
#undef VF_ISLAND_FIELD
|
|
}
|
|
|
|
inline void ReadBiomeMap(const VFJson::Value& J, FBiomeMapParams& P)
|
|
{
|
|
ReadField(J,"CellSize",P.CellSize); ReadField(J,"WarpStrength",P.WarpStrength);
|
|
ReadField(J,"WarpFrequency",P.WarpFrequency); ReadField(J,"BorderBlend",P.BorderBlend);
|
|
ReadField(J,"ReliefFrequency",P.ReliefFrequency); ReadField(J,"ReliefContrast",P.ReliefContrast);
|
|
ReadField(J,"MoistureFrequency",P.MoistureFrequency);
|
|
}
|
|
|
|
inline void ReadOperation(const VFJson::Value& J, UVoxelTerrainOpDefinition& O)
|
|
{
|
|
ReadField(J,"Type",O.Type);
|
|
#define VF_OPERATION_FIELD(Name) ReadField(J, #Name, O.Name);
|
|
VF_OPERATION_FIELD(TerraceStepHeight) VF_OPERATION_FIELD(TerraceHardness)
|
|
VF_OPERATION_FIELD(TerraceNoiseDisplacement) VF_OPERATION_FIELD(LayerLineSpacing)
|
|
VF_OPERATION_FIELD(LayerLineDepth) VF_OPERATION_FIELD(RibbingSpacing)
|
|
VF_OPERATION_FIELD(RibbingDepth) VF_OPERATION_FIELD(CliffStrength)
|
|
VF_OPERATION_FIELD(ScallopStrength) VF_OPERATION_FIELD(ScallopFrequency)
|
|
VF_OPERATION_FIELD(OverhangStrength) VF_OPERATION_FIELD(OverhangDepth)
|
|
VF_OPERATION_FIELD(OverhangFrequency) VF_OPERATION_FIELD(ArchDensity)
|
|
VF_OPERATION_FIELD(ArchMinRadius) VF_OPERATION_FIELD(ArchMaxRadius)
|
|
VF_OPERATION_FIELD(ColumnDensity) VF_OPERATION_FIELD(ColumnMinRadius)
|
|
VF_OPERATION_FIELD(ColumnMaxRadius) VF_OPERATION_FIELD(PitDensity)
|
|
VF_OPERATION_FIELD(PitMinRadius) VF_OPERATION_FIELD(PitMaxRadius)
|
|
VF_OPERATION_FIELD(PitDepth) VF_OPERATION_FIELD(ChimneyDensity)
|
|
VF_OPERATION_FIELD(ChimneyMinRadius) VF_OPERATION_FIELD(ChimneyMaxRadius)
|
|
VF_OPERATION_FIELD(ChimneyHeight) VF_OPERATION_FIELD(DomeDensity)
|
|
VF_OPERATION_FIELD(DomeMinRadius) VF_OPERATION_FIELD(DomeMaxRadius)
|
|
VF_OPERATION_FIELD(DomeHeightRatio) VF_OPERATION_FIELD(PinchDensity)
|
|
VF_OPERATION_FIELD(PinchStrength) VF_OPERATION_FIELD(PinchLength)
|
|
#undef VF_OPERATION_FIELD
|
|
}
|
|
|
|
inline void ReadBiome(const VFJson::Value& J, UVoxelBiomeDefinition& B)
|
|
{
|
|
ReadText(J,"BiomeName",B.BiomeName); ReadText(J,"BiomeDescription",B.BiomeDescription);
|
|
ReadLinearColor(J.Get("DebugColor"),B.DebugColor);
|
|
ReadField(J,"ReliefMin",B.ReliefMin); ReadField(J,"ReliefMax",B.ReliefMax);
|
|
ReadField(J,"MoistureMin",B.MoistureMin); ReadField(J,"MoistureMax",B.MoistureMax);
|
|
ReadField(J,"bOverrideTerrain",B.bOverrideTerrain); ReadField(J,"GeneratorType",B.GeneratorType);
|
|
ReadSurfaceParams(J.Get("SurfaceParams"),B.SurfaceParams);
|
|
ReadField(J,"bOverrideAtmosphere",B.bOverrideAtmosphere);
|
|
ReadLinearColor(J.Get("FogColor"),B.FogColor); ReadField(J,"FogDensity",B.FogDensity);
|
|
ReadLinearColor(J.Get("AmbientLightColor"),B.AmbientLightColor);
|
|
ReadField(J,"AmbientLightIntensity",B.AmbientLightIntensity);
|
|
ReadField(J,"MaterialPaletteIndex",B.MaterialPaletteIndex);
|
|
}
|
|
|
|
inline UVoxelStrateDefinition* ReadDefinition(
|
|
FStandaloneOwnerWorld& World, const VFJson::Value& Slot, int32 SlotIndex)
|
|
{
|
|
const VFJson::Value& J = Slot.Get("asset");
|
|
auto Definition = std::make_unique<UVoxelStrateDefinition>();
|
|
ReadText(J,"StrateName",Definition->StrateName);
|
|
ReadText(J,"StrateDescription",Definition->StrateDescription);
|
|
ReadField(J,"StrateHeightInChunks",Definition->StrateHeightInChunks);
|
|
ReadField(J,"TransitionType",Definition->TransitionType);
|
|
ReadField(J,"TransitionBlendChunks",Definition->TransitionBlendChunks);
|
|
ReadField(J,"GeneratorType",Definition->GeneratorType);
|
|
ReadField(J,"bEnableWorms",Definition->bEnableWorms);
|
|
ReadGenerationParams(Slot.Get("generation_params"),Definition->GenerationParams);
|
|
ReadSlabParams(J.Get("SlabParams"),Definition->SlabParams);
|
|
ReadMazeParams(J.Get("MazeParams"),Definition->MazeParams);
|
|
ReadVerticalShaftParams(J.Get("VerticalShaftParams"),Definition->VerticalShaftParams);
|
|
ReadFloatingIslandParams(J.Get("FloatingIslandParams"),Definition->FloatingIslandParams);
|
|
ReadDisturbances(Slot.Get("disturbances"),Definition->Disturbances);
|
|
ReadPassageConfig(Slot.Get("passage_config"),Definition->PassageConfig);
|
|
ReadSurfaceParams(J.Get("SurfaceParams"),Definition->SurfaceParams);
|
|
ReadBiomeMap(J.Get("BiomeMapParams"),Definition->BiomeMapParams);
|
|
ReadField(J,"bHasWater",Definition->bHasWater);
|
|
|
|
const auto& Biomes = J.Get("Biomes").AsArray();
|
|
Definition->Biomes.Reserve(static_cast<int32>(Biomes.size()));
|
|
for (const VFJson::Value& BiomeJson : Biomes)
|
|
{
|
|
auto Biome = std::make_unique<UVoxelBiomeDefinition>();
|
|
ReadBiome(BiomeJson,*Biome);
|
|
Definition->Biomes.Add(Biome.get());
|
|
World.BiomeStorage.push_back(std::move(Biome));
|
|
}
|
|
|
|
const auto& OperationEntries = Slot.Get("terrain_operation_assets").AsArray();
|
|
Definition->TerrainOperations.Reserve(static_cast<int32>(OperationEntries.size()));
|
|
for (int32 I = 0; I < static_cast<int32>(OperationEntries.size()); ++I)
|
|
{
|
|
const VFJson::Value& EntryJson = OperationEntries[static_cast<size_t>(I)];
|
|
const VFJson::Value& AssetJson = EntryJson.Get("asset");
|
|
const VFJson::Value& PathJson = EntryJson.Get("asset_path");
|
|
const FString Path = PathJson.IsString() ? FString(PathJson.String()) : FString{};
|
|
FStrateTerrainOpEntry Entry;
|
|
ReadField(EntryJson,"weight",Entry.Weight);
|
|
ReadField(EntryJson,"probability",Entry.Probability);
|
|
if (AssetJson.IsObject())
|
|
{
|
|
auto Operation = std::make_unique<UVoxelTerrainOpDefinition>();
|
|
ReadOperation(AssetJson,*Operation);
|
|
UVoxelTerrainOpDefinition* Raw = Operation.get();
|
|
World.OperationStorage.push_back(std::move(Operation));
|
|
Entry.Operation.Set(Raw,Path);
|
|
RegisterStandaloneAsset(Path,Raw);
|
|
}
|
|
else if (!Path.IsEmpty()) Entry.Operation = TSoftObjectPtr<UVoxelTerrainOpDefinition>(Path);
|
|
Definition->TerrainOperations.Add(std::move(Entry));
|
|
}
|
|
|
|
const FString SyntheticPath = FString::Printf("/Standalone/Strate_%d",SlotIndex);
|
|
Definition->PostLoad();
|
|
UVoxelStrateDefinition* Raw = Definition.get();
|
|
World.DefinitionStorage.push_back(std::move(Definition));
|
|
RegisterStandaloneAsset(SyntheticPath,Raw);
|
|
return Raw;
|
|
}
|
|
|
|
inline bool Resolve(const VFJson::Value& Root, FStandaloneOwnerWorld& Out, std::string& Error)
|
|
{
|
|
if (Root.Get("voxel_size_cm").Number() != VOXEL_SIZE)
|
|
{
|
|
Error = "export voxel_size_cm does not match the standalone VOXEL_SIZE";
|
|
return false;
|
|
}
|
|
Out.Seed = static_cast<int32>(Root.Get("seed").Integer());
|
|
Out.ClipRadius = static_cast<int32>(Root.Get("clip_radius").Integer(6));
|
|
Out.MaxClipLevel = static_cast<int32>(Root.Get("max_clip_level").Integer(8));
|
|
Out.FullResClipLevels = static_cast<int32>(Root.Get("full_res_clip_levels").Integer(2));
|
|
Out.CoarseTileCells = static_cast<int32>(Root.Get("coarse_tile_cells").Integer(16));
|
|
Out.RenderDistanceChunks = static_cast<int32>(Root.Get("render_distance_chunks").Integer(1536));
|
|
Out.StrateContentCutMinLevel = static_cast<int32>(Root.Get("strate_content_cut_min_level").Integer(9));
|
|
Out.bGenerateSkirts = Root.Get("generate_skirts").Boolean(true);
|
|
Out.SkirtCells = static_cast<int32>(Root.Get("skirt_cells").Integer(2));
|
|
Out.LODOctaveDrop = static_cast<int32>(Root.Get("lod_octave_drop").Integer(0));
|
|
ReadVector(Root.Get("viewer_start"),Out.ViewerStartVoxels);
|
|
Out.ViewerStartFound = Root.Get("viewer_start").Get("found_open_space").Boolean();
|
|
for (const VFJson::Value& SampleJson : Root.Get("density_samples").AsArray())
|
|
{
|
|
FStandaloneParitySample Sample;
|
|
ReadField(SampleJson,"x",Sample.PositionVoxels.X);
|
|
ReadField(SampleJson,"y",Sample.PositionVoxels.Y);
|
|
ReadField(SampleJson,"z",Sample.PositionVoxels.Z);
|
|
ReadField(SampleJson,"density",Sample.PluginDensity);
|
|
ReadField(SampleJson,"strate_index",Sample.StrateIndex);
|
|
Sample.Kind = SampleJson.Get("kind").String();
|
|
Out.DensitySamples.push_back(std::move(Sample));
|
|
}
|
|
|
|
Out.Settings = std::make_unique<UVoxelSettings>();
|
|
const VFJson::Value& SettingsJson = Root.Get("settings_asset");
|
|
Out.Settings->Seed = Out.Seed;
|
|
ReadField(Root,"origin_spine_radius",Out.Settings->OriginSpineRadius);
|
|
ReadField(Root,"world_radius_voxels",Out.Settings->WorldRadiusVoxels);
|
|
ReadField(Root,"edge_seal_thickness",Out.Settings->EdgeSealThickness);
|
|
ReadField(Root,"open_surface_entry",Out.Settings->bOpenSurfaceEntry);
|
|
ReadField(Root,"inter_strate_gap_chunks",Out.Settings->InterStrateGapChunks);
|
|
ReadField(SettingsJson,"total_strates",Out.Settings->TotalStrates);
|
|
ReadField(Root,"clip_radius",Out.Settings->ClipRadius);
|
|
ReadField(Root,"max_clip_level",Out.Settings->MaxClipLevel);
|
|
ReadField(Root,"full_res_clip_levels",Out.Settings->FullResClipLevels);
|
|
ReadField(Root,"coarse_tile_cells",Out.Settings->CoarseTileCells);
|
|
ReadField(Root,"render_distance_chunks",Out.Settings->RenderDistanceChunks);
|
|
ReadField(Root,"generate_skirts",Out.Settings->bGenerateSkirts);
|
|
ReadField(Root,"skirt_cells",Out.Settings->SkirtCells);
|
|
ReadField(Root,"lod_octave_drop",Out.Settings->LODOctaveDrop);
|
|
ReadField(Root,"strate_content_cut_min_level",Out.Settings->StrateContentCutMinLevel);
|
|
ReadField(SettingsJson,"TotalStrates",Out.Settings->TotalStrates);
|
|
ReadField(SettingsJson,"InterStrateGapChunks",Out.Settings->InterStrateGapChunks);
|
|
Out.Settings->StratePool.Reset();
|
|
Out.Settings->FixedStrates.Empty();
|
|
const auto& Strates = Root.Get("strates").AsArray();
|
|
Out.Settings->TotalStrates = static_cast<int32>(Strates.size());
|
|
for (int32 I = 0; I < static_cast<int32>(Strates.size()); ++I)
|
|
{
|
|
UVoxelStrateDefinition* Definition = ReadDefinition(Out,Strates[static_cast<size_t>(I)],I);
|
|
const FString SyntheticPath = FString::Printf("/Standalone/Strate_%d",I);
|
|
TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition;
|
|
SoftDefinition.Set(Definition,SyntheticPath);
|
|
Out.Settings->FixedStrates.Add(I,std::move(SoftDefinition));
|
|
}
|
|
if (Strates.empty()) { Error = "owner JSON contains no resolved strates"; return false; }
|
|
|
|
Out.Manager = std::make_unique<UVoxelStrateManager>();
|
|
if (!Out.Manager->Initialize(Out.Settings.get(),Out.Seed))
|
|
{
|
|
Error = "copied strate manager rejected the owner settings snapshot";
|
|
return false;
|
|
}
|
|
Out.Generator = std::make_unique<UVoxelGenerator>();
|
|
Out.Generator->InitializeSettings(Out.Settings.get());
|
|
Out.Generator->SetStrateManager(Out.Manager.get());
|
|
return true;
|
|
}
|
|
|
|
inline bool LoadJson(std::string_view Json,FStandaloneOwnerWorld& Out,std::string& Error)
|
|
{
|
|
VFJson::Value Root;
|
|
if(!VFJson::Parser(std::string(Json)).Parse(Root,Error))return false;
|
|
return Resolve(Root,Out,Error);
|
|
}
|
|
|
|
inline bool Load(const std::string& Path,FStandaloneOwnerWorld& Out,std::string& Error)
|
|
{
|
|
VFJson::Value Root;
|
|
if(!VFJson::Load(Path,Root,Error))return false;
|
|
return Resolve(Root,Out,Error);
|
|
}
|
|
}
|