public void Start()
{
TaskUtils.SetGlobalMultithreading(false);
var shaderContainerGO = FindObjectOfType <ComputeShaderContainerGameObject>();
var configuration = new FEConfiguration(new FilePathsConfiguration());
GlobalServicesProfileInfo servicesProfileInfo = new GlobalServicesProfileInfo();
var ultraUpdatableContainer = new UltraUpdatableContainer(
configuration.SchedulerConfiguration,
servicesProfileInfo,
configuration.UpdatableContainerConfiguration);
Dictionary <int, float> intensityPatternPixelsPerUnit = new Dictionary <int, float>()
{
{ 1, 1 }
};
int mipmapLevelToExtract = 2;
Dictionary <int, float> plateStampPixelsPerUnit = new Dictionary <int, float>()
{
{ 1, 5 }
};
_updatableContainer = new UltraUpdatableContainer(new MyUtSchedulerConfiguration(), new GlobalServicesProfileInfo(), new UltraUpdatableContainerConfiguration());
_provider = ESurfaceProviderInitializationHelper.ConstructProvider(
_updatableContainer, intensityPatternPixelsPerUnit, shaderContainerGO, mipmapLevelToExtract, plateStampPixelsPerUnit);
_patchesCreatorProxy = new GRing2PatchesCreatorProxy(ESurfaceProviderInitializationHelper.CreateRing2PatchesCreator(_updatableContainer, intensityPatternPixelsPerUnit));
RegeneratePatch();
}
public FEInitializingHelper(GameInitializationFields gameInitializationFields,
UltraUpdatableContainer updatableContainer, FEConfiguration configuration)
{
_gameInitializationFields = gameInitializationFields;
_updatableContainer = updatableContainer;
_configuration = configuration;
}
public static GRing2PatchesCreator CreateRing2PatchesCreator(UltraUpdatableContainer updatableContainer, Dictionary <int, float> intensityPatternPixelsPerUnit)
{
TextureConcieverUTProxy conciever = new TextureConcieverUTProxy();
updatableContainer.Add(conciever);
Ring2RandomFieldFigureGenerator figureGenerator = new Ring2RandomFieldFigureGenerator(new TextureRenderer(),
new Ring2RandomFieldFigureGeneratorConfiguration()
{
PixelsPerUnit = new Vector2(1, 1)
});
var utFigureGenerator = new RandomFieldFigureGeneratorUTProxy(figureGenerator);
updatableContainer.Add(utFigureGenerator);
var randomFieldFigureRepository = new Ring2RandomFieldFigureRepository(utFigureGenerator,
new Ring2RandomFieldFigureRepositoryConfiguration(2, new Vector2(20, 20)));
Quadtree <Ring2Region> regionsTree = Ring2TestUtils.CreateRegionsTreeWithPath3(randomFieldFigureRepository);
return(new GRing2PatchesCreator(
new MonoliticRing2RegionsDatabase(regionsTree),
new GRing2RegionsToPatchTemplateConventer(),
new Ring2PatchTemplateCombiner(),
new Ring2PatchCreator(),
new Ring2IntensityPatternProvider(conciever),
new GRing2Deviser(),
new Ring2PatchesOverseerConfiguration()
{
IntensityPatternPixelsPerUnit = intensityPatternPixelsPerUnit
}
));
}
private void InitializeTerrainDb(bool useTerrainDetailFileCache = false)
{
var ultraUpdatableContainer = new UltraUpdatableContainer(new MyUtSchedulerConfiguration(),
new GlobalServicesProfileInfo(), new UltraUpdatableContainerConfiguration());
var feConfiguration = new FEConfiguration(new FilePathsConfiguration());
var feGRingConfiguration = new FeGRingConfiguration();
feGRingConfiguration.FeConfiguration = feConfiguration;
feConfiguration.TerrainShapeDbConfiguration.UseTextureSavingToDisk = useTerrainDetailFileCache;
feConfiguration.TerrainShapeDbConfiguration.UseTextureLoadingFromDisk = useTerrainDetailFileCache;
feConfiguration.EngraveRoadsInTerrain = false;
TaskUtils.SetGlobalMultithreading(feConfiguration.Multithreading);
TaskUtils.SetMultithreadingOverride(true);
_gameInitializationFields.SetField(feConfiguration.Repositioner);
_gameInitializationFields.SetField(feConfiguration.HeightDenormalizer);
var initializingHelper =
new FEInitializingHelper(_gameInitializationFields, ultraUpdatableContainer, feConfiguration);
initializingHelper.InitializeUTService(new TextureConcieverUTProxy());
initializingHelper.InitializeUTService(new UnityThreadComputeShaderExecutorObject());
initializingHelper.InitializeUTService(new CommonExecutorUTProxy());
initializingHelper.InitializeUTRendererProxy();
var finalTerrainShapeDb = new FETerrainShapeDbInitialization(ultraUpdatableContainer,
_gameInitializationFields, feConfiguration, _filePathsConfiguration);
finalTerrainShapeDb.Start();
}
public FinalTerrainInitialization(UltraUpdatableContainer ultraUpdatableContainer,
GameInitializationFields gameInitializationFields, FEConfiguration configuration, FeGRingConfiguration gRingConfiguration)
{
_ultraUpdatableContainer = ultraUpdatableContainer;
_gameInitializationFields = gameInitializationFields;
_configuration = configuration;
_gRingConfiguration = gRingConfiguration;
}
public FETerrainShapeDbInitialization(UltraUpdatableContainer ultraUpdatableContainer,
GameInitializationFields gameInitializationFields, FEConfiguration configuration,
FilePathsConfiguration filePathsConfiguration)
{
_ultraUpdatableContainer = ultraUpdatableContainer;
_gameInitializationFields = gameInitializationFields;
_configuration = configuration;
_filePathsConfiguration = filePathsConfiguration;
}
public static UltraUpdatableContainer InitializeFinalElements(FEConfiguration configuration, ComputeShaderContainerGameObject containerGameObject,
GameInitializationFields gameInitializationFields, Dictionary <int, Ring2RegionsDbGeneratorConfiguration> ring2RegionsDatabasesConfiguration = null
, bool initializeLegacyDesignBodySpotUpdater = false)
{
TaskUtils.SetGlobalMultithreading(configuration.Multithreading);
return(TaskUtils.ExecuteFunctionWithOverridenMultithreading(true, () =>
{
var servicesProfileInfo = new GlobalServicesProfileInfo();
gameInitializationFields.SetField(servicesProfileInfo);
var ultraUpdatableContainer = new UltraUpdatableContainer(
configuration.SchedulerConfiguration,
servicesProfileInfo,
configuration.UpdatableContainerConfiguration);
configuration.TerrainShapeDbConfiguration.UseTextureSavingToDisk = true;
gameInitializationFields.SetField(containerGameObject);
gameInitializationFields.SetField(configuration.Repositioner);
gameInitializationFields.SetField(configuration.HeightDenormalizer);
var initializingHelper =
new FEInitializingHelper(gameInitializationFields, ultraUpdatableContainer, configuration);
initializingHelper.InitializeUTService(new TextureConcieverUTProxy());
initializingHelper.InitializeUTService(new UnityThreadComputeShaderExecutorObject());
initializingHelper.InitializeUTService(new CommonExecutorUTProxy());
initializingHelper.CreatePathProximityTextureDb();
if (initializeLegacyDesignBodySpotUpdater)
{
initializingHelper.InitializeDesignBodySpotUpdater();
}
initializingHelper.InitializeUTRendererProxy();
initializingHelper.InitializeUTService(new MeshGeneratorUTProxy(new MeshGeneratorService()));
if (ring2RegionsDatabasesConfiguration != null)
{
initializingHelper.InitializeComplexRing2RegionsDatabase(ring2RegionsDatabasesConfiguration);
}
else
{
initializingHelper.InitializeMonoliticRing2RegionsDatabase();
}
//var finalTerrainInitialization = new FinalTerrainInitialization(_ultraUpdatableContainer, _gameInitializationFields, _configuration, FeGRingConfiguration);
//finalTerrainInitialization.Start();
initializingHelper.InitializeGlobalInstancingContainer();
//var finalVegetation = new FinalVegetation(_gameInitializationFields, _ultraUpdatableContainer, VegetationConfiguration);
//finalVegetation.Start();
return ultraUpdatableContainer;
}));
}
public FinalVegetation(GameInitializationFields initializationFields,
UltraUpdatableContainer ultraUpdatableContainer, FinalVegetationConfiguration veConfiguration, UniformsAndComputeBuffersPack materialCommonPack = null)
{
this._initializationFields = initializationFields;
this._ultraUpdatableContainer = ultraUpdatableContainer;
_veConfiguration = veConfiguration;
if (materialCommonPack == null)
{
materialCommonPack = new UniformsAndComputeBuffersPack(new UniformsPack(), new ComputeBuffersPack());
}
_materialCommonPack = materialCommonPack;
}
public static ESurfacePatchProvider ConstructProvider(UltraUpdatableContainer updatableContainer, Dictionary <int, float> intensityPatternPixelsPerUnit,
ComputeShaderContainerGameObject shaderContainerGO, int mipmapLevelToExtract, Dictionary <int, float> plateStampPixelsPerUnit)
{
var ring2ShaderRepository = Ring2PlateShaderRepository.Create();
TextureConcieverUTProxy conciever = new TextureConcieverUTProxy();
updatableContainer.Add(conciever);
var ring2PatchesPainterUtProxy = new Ring2PatchesPainterUTProxy(
new Ring2PatchesPainter(
new Ring2MultishaderMaterialRepository(ring2ShaderRepository, Ring2ShaderNames.ShaderNames)));
updatableContainer.Add(ring2PatchesPainterUtProxy);
UTRing2PlateStamperProxy stamperProxy = new UTRing2PlateStamperProxy(
new Ring2PlateStamper(new Ring2PlateStamperConfiguration()
{
PlateStampPixelsPerUnit = plateStampPixelsPerUnit
}, shaderContainerGO));
updatableContainer.Add(stamperProxy);
UTTextureRendererProxy textureRendererProxy = new UTTextureRendererProxy(new TextureRendererService(
new MultistepTextureRenderer(shaderContainerGO), new TextureRendererServiceConfiguration()
{
StepSize = new Vector2(500, 500)
}));
updatableContainer.Add(textureRendererProxy);
CommonExecutorUTProxy commonExecutorUtProxy = new CommonExecutorUTProxy(); //todo
updatableContainer.Add(commonExecutorUtProxy);
Ring2PatchStamplingOverseerFinalizer patchStamperOverseerFinalizer =
new Ring2PatchStamplingOverseerFinalizer(stamperProxy, textureRendererProxy, commonExecutorUtProxy);
MipmapExtractor mipmapExtractor = new MipmapExtractor(textureRendererProxy);
var patchesCreatorProxy = new GRing2PatchesCreatorProxy(CreateRing2PatchesCreator(updatableContainer, intensityPatternPixelsPerUnit));
return(new ESurfacePatchProvider(patchesCreatorProxy, patchStamperOverseerFinalizer, commonExecutorUtProxy, mipmapExtractor, mipmapLevelToExtract));
}
public void Start()
{
var msw = new MyStopWatch();
msw.StartSegment("Start");
TaskUtils.ExecuteActionWithOverridenMultithreading(true, () =>
{
_feConfiguration = new FEConfiguration(new FilePathsConfiguration())
{
Multithreading = Multithreading
};
_feConfiguration.EngraveTerrainFeatures = true;
_feConfiguration.EngraveRoadsInTerrain = true;
_feConfiguration.TerrainShapeDbConfiguration.UseTextureLoadingFromDisk = true;
_feConfiguration.TerrainShapeDbConfiguration.UseTextureSavingToDisk = false;
_feConfiguration.TerrainShapeDbConfiguration.MergeTerrainDetail = true;
var containerGameObject = GameObject.FindObjectOfType <ComputeShaderContainerGameObject>();
VegetationConfiguration.FeConfiguration = _feConfiguration;
_heightmapListenersContainer = new HeightmapSegmentFillingListenersContainer();
_gameInitializationFields = new GameInitializationFields();
_updaterUntilException = new UpdaterUntilException();
_movementCustodian = new TravellerMovementCustodian(Traveller);
_gameInitializationFields.SetField(_movementCustodian);
_ultraUpdatableContainer = ETerrainTestUtils.InitializeFinalElements(_feConfiguration, containerGameObject, _gameInitializationFields, initializeLegacyDesignBodySpotUpdater: false);
var startConfiguration = ETerrainHeightPyramidFacadeStartConfiguration.DefaultConfiguration;
var initializingHelper = InitializeETerrain(startConfiguration);
initializingHelper.InitializeUTService(new UnityThreadComputeShaderExecutorObject());
InitializeUI(startConfiguration);
Traveller.transform.position = new Vector3(startConfiguration.InitialTravellerPosition.x, Traveller.transform.position.y, startConfiguration.InitialTravellerPosition.y);
});
Debug.Log("Init time " + msw.CollectResults());
_initializationWasSuccessfull = true;
}
private ETerrainHeightPyramidFacade StartTerrainThings(MeshGeneratorUTProxy meshGeneratorUtProxy, UTTextureRendererProxy textureRendererProxy,
ComputeShaderContainerGameObject containerGameObject, List <HeightPyramidLevel> startConfigurationHeightPyramidLevels)
{
var startConfiguration = ETerrainHeightPyramidFacadeStartConfiguration.DefaultConfiguration;
//startConfiguration.HeightPyramidLevels = new List<HeightPyramidLevel>() {HeightPyramidLevel.Top};
startConfiguration.HeightPyramidLevels = startConfigurationHeightPyramidLevels;
ETerrainHeightBuffersManager buffersManager = new ETerrainHeightBuffersManager();
var eTerrainHeightPyramidFacade = new ETerrainHeightPyramidFacade(buffersManager, meshGeneratorUtProxy, textureRendererProxy, startConfiguration);
var perLevelTemplates = eTerrainHeightPyramidFacade.GenerateLevelTemplates();
var levels = startConfiguration.HeightPyramidLevels;
buffersManager.InitializeBuffers(levels.ToDictionary(c => c, c => new EPyramidShaderBuffersGeneratorPerRingInput()
{
FloorTextureResolution = startConfiguration.CommonConfiguration.FloorTextureSize.X, //TODO i use only X, - works only for squares
HeightMergeRanges = perLevelTemplates[c].PerRingTemplates.ToDictionary(k => k.Key, k => k.Value.HeightMergeRange),
CeilSliceWorldSize = startConfiguration.PerLevelConfigurations[c].FloorTextureWorldSize.x, // TODO works only for square pyramids - i use width
RingUvRanges = startConfiguration.CommonConfiguration.RingsUvRange
}), startConfiguration.CommonConfiguration.MaxLevelsCount, startConfiguration.CommonConfiguration.MaxRingsPerLevelCount);
var configuration = new FEConfiguration(new FilePathsConfiguration());
GlobalServicesProfileInfo servicesProfileInfo = new GlobalServicesProfileInfo();
var ultraUpdatableContainer = new UltraUpdatableContainer(
configuration.SchedulerConfiguration,
servicesProfileInfo,
configuration.UpdatableContainerConfiguration);
var updatableContainer = new UpdatableContainer();
var intensityPatternPixelsPerUnit = new Dictionary <int, float>()
{
{ 1, 1 }
};
int mipmapLevelToExtract = 2;
var plateStampPixelsPerUnit = new Dictionary <int, float>()
{
{ 1, 3 }
};
var surfacePatchProvider = ESurfaceProviderInitializationHelper.ConstructProvider(
ultraUpdatableContainer, intensityPatternPixelsPerUnit, containerGameObject, mipmapLevelToExtract, plateStampPixelsPerUnit);
var surfaceTextureFormat = RenderTextureFormat.ARGB32;
eTerrainHeightPyramidFacade.Start(perLevelTemplates,
new Dictionary <EGroundTextureType, OneGroundTypeLevelTextureEntitiesGenerator>()
{
//{
// EGroundTextureType.SurfaceTexture, new OneGroundTypeLevelTextureEntitiesGenerator()
// {
// SegmentFillingListenerGeneratorFunc = (level) =>
// {
// var floorTexture = EGroundTextureGenerator.GenerateEmptyGroundTexture(startConfiguration.CommonConfiguration.FloorTextureSize,
// surfaceTextureFormat);
// var segmentsPlacer = new ESurfaceSegmentPlacer(textureRendererProxy, floorTexture
// , startConfiguration.CommonConfiguration.SlotMapSize, startConfiguration.CommonConfiguration.FloorTextureSize);
// var pyramidLevelManager = new GroundLevelTexturesManager(startConfiguration.CommonConfiguration.SlotMapSize);
// var segmentModificationManager = new SoleLevelGroundTextureSegmentModificationsManager(segmentsPlacer, pyramidLevelManager);
// return new SegmentFillingListenerWithFloorTexture()
// {
// FloorTexture = floorTexture,
// SegmentFillingListener =
// new LambdaSegmentFillingListener(
// (c) =>
// {
// var segmentLength = startConfiguration.PerLevelConfigurations[level].BiggestShapeObjectInGroupLength;
// var sap = c.SegmentAlignedPosition;
// MyRectangle surfaceWorldSpaceRectangle = new MyRectangle(sap.X * segmentLength, sap.Y * segmentLength,
// segmentLength, segmentLength);
// var texturesPack = surfacePatchProvider.ProvideSurfaceDetailAsync(surfaceWorldSpaceRectangle, new FlatLod(1, 1)).Result;
// if (texturesPack != null)
// {
// var mainTexture = texturesPack.MainTexture;
// segmentModificationManager.AddSegmentAsync(mainTexture, c.SegmentAlignedPosition);
// GameObject.Destroy(mainTexture);
// }
// //}
// },
// (c) => { },
// (c) => { })
// };
// },
// }
//}
}
);
Traveller.transform.position = new Vector3(startConfiguration.InitialTravellerPosition.x, 0, startConfiguration.InitialTravellerPosition.y);
eTerrainHeightPyramidFacade.DisableLevelShapes(HeightPyramidLevel.Bottom);
return(eTerrainHeightPyramidFacade);
}
// Use this for initialization
void Start()
{
_configuration = new FEConfiguration(new FilePathsConfiguration())
{
Multithreading = UseMultithreading
};
_configuration.TerrainShapeDbConfiguration = TerrainShapeDbConfiguration;
FeGRingConfiguration.FeConfiguration = _configuration;
VegetationConfiguration.FeConfiguration = _configuration;
TaskUtils.SetGlobalMultithreading(_configuration.Multithreading);
TaskUtils.ExecuteActionWithOverridenMultithreading(true, () =>
{
MyProfiler.BeginSample("Sample1");
msw.StartSegment("Game initialization");
GlobalServicesProfileInfo servicesProfileInfo = new GlobalServicesProfileInfo();
if (GraphicsOverlay != null)
{
GraphicsOverlay.ServicesProfileInfo = servicesProfileInfo;
}
_ultraUpdatableContainer = new UltraUpdatableContainer(
_configuration.SchedulerConfiguration,
servicesProfileInfo,
_configuration.UpdatableContainerConfiguration);
_configuration.TerrainShapeDbConfiguration.UseTextureSavingToDisk = true;
_gameInitializationFields.SetField(ContainerGameObject);
_gameInitializationFields.SetField(_configuration.Repositioner);
_gameInitializationFields.SetField(_configuration.HeightDenormalizer);
var initializingHelper =
new FEInitializingHelper(_gameInitializationFields, _ultraUpdatableContainer, _configuration);
initializingHelper.InitializeUTService(new TextureConcieverUTProxy());
initializingHelper.InitializeUTService(new UnityThreadComputeShaderExecutorObject(_configuration.UseMultistepComputeShaderExecution));
initializingHelper.InitializeUTService(new CommonExecutorUTProxy());
initializingHelper.CreatePathProximityTextureDb();
SetInitialCameraPosition();
initializingHelper.InitializeDesignBodySpotUpdater();
initializingHelper.InitializeUTRendererProxy();
initializingHelper.InitializeUTService(new MeshGeneratorUTProxy(new MeshGeneratorService()));
initializingHelper.InitializeMonoliticRing2RegionsDatabase();
var finalSurfacePathInitialization =
new Ring2PatchInitializer(_gameInitializationFields, _ultraUpdatableContainer, new Ring2PatchInitializerConfiguration(_configuration));
finalSurfacePathInitialization.Start();
var finalTerrainInitialization =
new FinalTerrainInitialization(_ultraUpdatableContainer, _gameInitializationFields, _configuration, FeGRingConfiguration);
finalTerrainInitialization.Start();
initializingHelper.InitializeGlobalInstancingContainer();
var finalVegetation = new FinalVegetation(_gameInitializationFields, _ultraUpdatableContainer, VegetationConfiguration);
finalVegetation.Start();
});
MyProfiler.EndSample();
}
public Ring2PatchInitializer(GameInitializationFields gameInitializationFields, UltraUpdatableContainer ultraUpdatableContainer, Ring2PatchInitializerConfiguration ring2InitializerConfiguration)
{
_gameInitializationFields = gameInitializationFields;
_ultraUpdatableContainer = ultraUpdatableContainer;
_ring2InitializerConfiguration = ring2InitializerConfiguration;
}
public static OneGroundTypeLevelTextureEntitiesGenerator CreateHeightTextureEntitiesGenerator(
ETerrainHeightPyramidFacadeStartConfiguration startConfiguration, GameInitializationFields initializationFields,
UltraUpdatableContainer updatableContainer
, HeightmapSegmentFillingListenersContainer heightmapListenersesContainer)
{
startConfiguration.CommonConfiguration.UseNormalTextures = true;
var textureRendererProxy = initializationFields.Retrive <UTTextureRendererProxy>();
var dbProxy = initializationFields.Retrive <TerrainShapeDbProxy>();
var repositioner = initializationFields.Retrive <Repositioner>();
return(new OneGroundTypeLevelTextureEntitiesGenerator
{
FloorTextureArrayGenerator = () =>
{
var outList = new List <EGroundTexture>()
{
new EGroundTexture(
texture: EGroundTextureGenerator.GenerateEmptyGroundTextureArray(startConfiguration.CommonConfiguration.FloorTextureSize
, startConfiguration.HeightPyramidLevels.Count, startConfiguration.CommonConfiguration.HeightTextureFormat),
textureType: EGroundTextureType.HeightMap
),
};
if (startConfiguration.CommonConfiguration.UseNormalTextures)
{
outList.Add(
new EGroundTexture(
texture: EGroundTextureGenerator.GenerateEmptyGroundTextureArray(startConfiguration.CommonConfiguration.FloorTextureSize
, startConfiguration.HeightPyramidLevels.Count, startConfiguration.CommonConfiguration.NormalTextureFormat),
textureType: EGroundTextureType.NormalTexture
)
);
}
return outList;
},
SegmentFillingListenerGeneratorFunc = (level, floorTextureArrays) =>
{
var usedGroundTypes = new List <EGroundTextureType>()
{
EGroundTextureType.HeightMap
};
if (startConfiguration.CommonConfiguration.UseNormalTextures)
{
usedGroundTypes.Add(EGroundTextureType.NormalTexture);
}
var segmentModificationManagers = usedGroundTypes.ToDictionary(groundType => groundType,
groundType =>
{
var groundTexture = floorTextureArrays.First(c => c.TextureType == groundType);
var segmentsPlacer = new HeightSegmentPlacer(
textureRendererProxy, initializationFields.Retrive <CommonExecutorUTProxy>(), groundTexture.Texture
, level.GetIndex(), startConfiguration.CommonConfiguration.SlotMapSize, startConfiguration.CommonConfiguration.FloorTextureSize
, startConfiguration.CommonConfiguration.InterSegmentMarginSize, startConfiguration.CommonConfiguration.SegmentTextureResolution
, startConfiguration.CommonConfiguration.MergeSegmentsInFloorTexture
);
var pyramidLevelManager = new GroundLevelTexturesManager(startConfiguration.CommonConfiguration.SlotMapSize);
return new SoleLevelGroundTextureSegmentModificationsManager(segmentsPlacer, pyramidLevelManager);
});
var otherThreadExecutor = new OtherThreadCompoundSegmentFillingOrdersExecutorProxy("Height-" + level.ToString(),
new CompoundSegmentOrdersFillingExecutor <TerrainDescriptionOutput>(
async(sap) =>
{
var surfaceWorldSpaceRectangle = ETerrainUtils.TerrainShapeSegmentAlignedPositionToWorldSpaceArea(level,
startConfiguration.PerLevelConfigurations[level], sap);
var terrainDescriptionOutput = await dbProxy.Query(new TerrainDescriptionQuery()
{
QueryArea = repositioner.InvMove(surfaceWorldSpaceRectangle),
RequestedElementDetails = new List <TerrainDescriptionQueryElementDetail>()
{
new TerrainDescriptionQueryElementDetail()
{
Resolution = ETerrainUtils.HeightPyramidLevelToTerrainShapeDatabaseResolution(level),
RequiredMergeStatus = RequiredCornersMergeStatus.MERGED,
Type = TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY
},
new TerrainDescriptionQueryElementDetail()
{
Resolution = ETerrainUtils.HeightPyramidLevelToTerrainShapeDatabaseResolution(level),
RequiredMergeStatus = RequiredCornersMergeStatus.NOT_MERGED,
Type = TerrainDescriptionElementTypeEnum.NORMAL_ARRAY
},
}
});
return terrainDescriptionOutput;
},
async(sap, terrainDescriptionOutput) =>
{
var heightSegmentTexture = terrainDescriptionOutput.GetElementOfType(TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY)
.TokenizedElement.DetailElement.Texture.Texture;
await segmentModificationManagers[EGroundTextureType.HeightMap].AddSegmentAsync(heightSegmentTexture, sap);
if (startConfiguration.CommonConfiguration.UseNormalTextures)
{
var normalSegmentTexture = terrainDescriptionOutput.GetElementOfType(TerrainDescriptionElementTypeEnum.NORMAL_ARRAY)
.TokenizedElement.DetailElement.Texture.Texture;
await segmentModificationManagers[EGroundTextureType.NormalTexture].AddSegmentAsync(normalSegmentTexture, sap);
}
},
async(terrainDescriptionOutput) =>
{
await dbProxy.DisposeTerrainDetailElement(terrainDescriptionOutput
.GetElementOfType(TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY).TokenizedElement.Token);
if (startConfiguration.CommonConfiguration.UseNormalTextures)
{
await dbProxy.DisposeTerrainDetailElement(terrainDescriptionOutput
.GetElementOfType(TerrainDescriptionElementTypeEnum.NORMAL_ARRAY).TokenizedElement.Token);
}
}
));
updatableContainer.AddOtherThreadProxy(otherThreadExecutor);
var fillingListener = new UnityThreadCompoundSegmentFillingListener(otherThreadExecutor);
heightmapListenersesContainer.AddListener(level, fillingListener);
var travellerCustodian = initializationFields.Retrive <TravellerMovementCustodian>();
travellerCustodian.AddLimiter(() => new MovementBlockingProcess()
{
ProcessName = "HeightSegmentsGenerationProcess " + level, BlockCount = fillingListener.BlockingProcessesCount()
});
//initializationFields.Retrive<InitialSegmentsGenerationInspector>().SetConditionToCheck(() => fillingListener.BlockingProcessesCount() == 0);
return fillingListener;
}
});
}
public static OneGroundTypeLevelTextureEntitiesGenerator CreateSurfaceTextureEntitiesGenerator(
FEConfiguration configuration, ETerrainHeightPyramidFacadeStartConfiguration startConfiguration, GameInitializationFields gameInitializationFields
, UltraUpdatableContainer ultraUpdatableContainer)
{
var repositioner = gameInitializationFields.Retrive <Repositioner>();
var surfaceTextureFormat = RenderTextureFormat.ARGB32;
var commonExecutor = gameInitializationFields.Retrive <CommonExecutorUTProxy>();
var feRing2PatchConfiguration = new Ring2PatchInitializerConfiguration(configuration);
feRing2PatchConfiguration.Ring2PlateStamperConfiguration.PlateStampPixelsPerUnit =
feRing2PatchConfiguration.Ring2PlateStamperConfiguration.PlateStampPixelsPerUnit.ToDictionary(
c => c.Key,
c => c.Value * Mathf.Pow(2, feRing2PatchConfiguration.MipmapLevelToExtract)
);
var patchInitializer = new Ring2PatchInitializer(gameInitializationFields, ultraUpdatableContainer, feRing2PatchConfiguration);
patchInitializer.Start();
var mipmapExtractor = new MipmapExtractor(gameInitializationFields.Retrive <UTTextureRendererProxy>());
var patchesCreatorProxy = gameInitializationFields.Retrive <GRing2PatchesCreatorProxy>();
var patchStamperOverseerFinalizer = gameInitializationFields.Retrive <Ring2PatchStamplingOverseerFinalizer>();
var surfacePatchProvider = new ESurfacePatchProvider(patchesCreatorProxy, patchStamperOverseerFinalizer, commonExecutor,
mipmapExtractor, feRing2PatchConfiguration.MipmapLevelToExtract);
var cachedSurfacePatchProvider =
new CachedESurfacePatchProvider(surfacePatchProvider
, new InMemoryAssetsCache <ESurfaceTexturesPackToken, NullableESurfaceTexturesPack>(
FETerrainShapeDbInitialization.CreateLevel2AssetsCache <ESurfaceTexturesPackToken, NullableESurfaceTexturesPack>(
cachingConfiguration: new CachingConfiguration()
{
SaveAssetsToFile = true,
UseFileCaching = true,
}
, new InMemoryCacheConfiguration() /*{ MaxTextureMemoryUsed = 0}*/
, new ESurfaceTexturesPackEntityActionsPerformer(commonExecutor)
, new ESurfaceTexturesPackFileManager(commonExecutor, configuration.FilePathsConfiguration.SurfacePatchCachePath))));
cachedSurfacePatchProvider.Initialize().Wait();
var cachedSurfacePatchDbProxy = new ESurfacePatchDbProxy(cachedSurfacePatchProvider);
ultraUpdatableContainer.AddOtherThreadProxy(cachedSurfacePatchDbProxy);
var textureRendererProxy = gameInitializationFields.Retrive <UTTextureRendererProxy>();
return(new OneGroundTypeLevelTextureEntitiesGenerator()
{
FloorTextureArrayGenerator = () =>
{
return new List <EGroundTexture>()
{
new EGroundTexture(EGroundTextureGenerator.GenerateEmptyGroundTextureArray(startConfiguration.CommonConfiguration.FloorTextureSize,
startConfiguration.HeightPyramidLevels.Count, surfaceTextureFormat),
EGroundTextureType.SurfaceTexture)
};
},
SegmentFillingListenerGeneratorFunc = (level, floorTextureArrays) =>
{
var floorTextureArray = floorTextureArrays.First(c => c.TextureType == EGroundTextureType.SurfaceTexture);
var segmentsPlacer = new ESurfaceSegmentPlacer(textureRendererProxy, floorTextureArray.Texture, level.GetIndex()
, startConfiguration.CommonConfiguration.SlotMapSize, startConfiguration.CommonConfiguration.FloorTextureSize);
var pyramidLevelManager = new GroundLevelTexturesManager(startConfiguration.CommonConfiguration.SlotMapSize);
var segmentModificationManager = new SoleLevelGroundTextureSegmentModificationsManager(segmentsPlacer, pyramidLevelManager);
var otherThreadExecutor = new OtherThreadCompoundSegmentFillingOrdersExecutorProxy("ESurface-" + level.ToString(),
new CompoundSegmentOrdersFillingExecutor <TokenizedESurfaceTexturesPackToken>(
async(sap) =>
{
var surfaceWorldSpaceRectangle = ETerrainUtils.SurfaceTextureSegmentAlignedPositionToWorldSpaceArea(level,
startConfiguration.PerLevelConfigurations[level], sap);
var lod = ETerrainUtils.HeightPyramidLevelToSurfaceTextureFlatLod(level);
return await cachedSurfacePatchDbProxy.ProvideSurfaceDetail(repositioner.InvMove(surfaceWorldSpaceRectangle), lod);
},
async(sap, packAndToken) =>
{
var pack = packAndToken.Pack;
if (pack != null)
{
var mainTexture = pack.MainTexture;
await segmentModificationManager.AddSegmentAsync(mainTexture, sap);
}
},
segmentRemovalFunc: async(packAndToken) =>
{
if (packAndToken != null)
{
var pack = packAndToken.Pack;
if (pack != null)
{
Preconditions.Assert(packAndToken.Token != null, "Token is null. Unexpected");
cachedSurfacePatchDbProxy.RemoveSurfaceDetailAsync(pack, packAndToken.Token);
}
}
}
));
ultraUpdatableContainer.AddOtherThreadProxy(otherThreadExecutor);
var fillingListener = new UnityThreadCompoundSegmentFillingListener(otherThreadExecutor);
var travellerCustodian = gameInitializationFields.Retrive <TravellerMovementCustodian>();
travellerCustodian.AddLimiter(() => new MovementBlockingProcess()
{
BlockCount = fillingListener.BlockingProcessesCount(), ProcessName = "SurfaceSegmentsGeneration " + level
});
return fillingListener;
}
});
}
