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();
}
private FEInitializingHelper InitializeETerrain(ETerrainHeightPyramidFacadeStartConfiguration startConfiguration)
{
startConfiguration.CommonConfiguration.YScale = _gameInitializationFields.Retrive <HeightDenormalizer>().DenormalizationMultiplier;
startConfiguration.HeightPyramidLevels = new List <HeightPyramidLevel>()
{
HeightPyramidLevel.Top, HeightPyramidLevel.Mid, HeightPyramidLevel.Bottom
};
var buffersManager = new ETerrainHeightBuffersManager();
_eTerrainHeightPyramidFacade = new ETerrainHeightPyramidFacade(buffersManager,
_gameInitializationFields.Retrive <MeshGeneratorUTProxy>(),
_gameInitializationFields.Retrive <UTTextureRendererProxy>(), startConfiguration);
var perLevelTemplates = _eTerrainHeightPyramidFacade.GenerateLevelTemplates();
var levels = startConfiguration.PerLevelConfigurations.Keys.Where(c => startConfiguration.HeightPyramidLevels.Contains(c));
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 dbInitialization =
new FETerrainShapeDbInitialization(_ultraUpdatableContainer, _gameInitializationFields, _feConfiguration, new FilePathsConfiguration());
dbInitialization.Start();
var initializingHelper = new FEInitializingHelper(_gameInitializationFields, _ultraUpdatableContainer, _feConfiguration);
initializingHelper.InitializeGlobalInstancingContainer();
_eTerrainHeightPyramidFacade.Start(perLevelTemplates,
new Dictionary <EGroundTextureType, OneGroundTypeLevelTextureEntitiesGenerator>
{
[EGroundTextureType.HeightMap] = ETerrainInitializationHelper.CreateHeightTextureEntitiesGenerator(
startConfiguration, _gameInitializationFields, _ultraUpdatableContainer, _heightmapListenersContainer),
[EGroundTextureType.SurfaceTexture] = ETerrainInitializationHelper.CreateSurfaceTextureEntitiesGenerator(
_feConfiguration, startConfiguration, _gameInitializationFields, _ultraUpdatableContainer)
}
);
return(initializingHelper);
}
public TerrainShapeDbUnderTest(bool useTextureSavingToDisk = false, bool useCornerMerging = false,
string terrainDetailFilePath = "C:\\unityCache\\", bool useTextureLoadingFromDisk = false)
{
CommonExecutorUTProxy commonExecutorUtProxy = new CommonExecutorUTProxy();
ComputeShaderContainerGameObject containerGameObject = GameObject.FindObjectOfType <ComputeShaderContainerGameObject>();
var globalHeightTexture = CreateGlobalHeightTexture(commonExecutorUtProxy);
UTTextureRendererProxy textureRendererProxy = new UTTextureRendererProxy(new TextureRendererService(
new MultistepTextureRenderer(containerGameObject), new TextureRendererServiceConfiguration()
{
StepSize = new Vector2(400, 400)
}));
UnityThreadComputeShaderExecutorObject computeShaderExecutorObject = new UnityThreadComputeShaderExecutorObject();
var terrainDetailGenerator = Ring1DebugObjectV2.CreateTerrainDetailGenerator(
globalHeightTexture, textureRendererProxy, commonExecutorUtProxy, computeShaderExecutorObject,
containerGameObject);
TerrainDetailCornerMerger merger = null;
LateAssignFactory <BaseTerrainDetailProvider> detailProviderFactory = new LateAssignFactory <BaseTerrainDetailProvider>();
if (useCornerMerging)
{
merger = new TerrainDetailCornerMerger(detailProviderFactory, new TerrainDetailAlignmentCalculator(240), textureRendererProxy, new TextureConcieverUTProxy(),
new CommonExecutorUTProxy(), new TerrainDetailCornerMergerConfiguration());
}
var terrainDetailProvider = Ring1DebugObjectV2.CreateTerrainDetailProvider(terrainDetailGenerator, merger);
_shapeDb = FETerrainShapeDbInitialization.CreateTerrainShapeDb(terrainDetailProvider, commonExecutorUtProxy
, new TerrainDetailAlignmentCalculator(240), useCornerMerging, useTextureSavingToDisk, useTextureLoadingFromDisk
, new TerrainDetailFileManager(terrainDetailFilePath, commonExecutorUtProxy));
var baseProvider = new FromTerrainDbBaseTerrainDetailProvider(_shapeDb);
detailProviderFactory.Assign(baseProvider);
terrainDetailGenerator.SetBaseTerrainDetailProvider(baseProvider);
}
// Use this for initialization
void Start()
{
_updatableContainer = new UpdatableContainer();
TaskUtils.SetGlobalMultithreading(false);
_ring1Tree = new Ring1Tree();
//////////////////
var rgbaMainTexture = SavingFileManager.LoadPngTextureFromFile(@"C:\inz\cont\n49_e019_1arc_v3.png", 3600,
3600,
TextureFormat.ARGB32, true, false);
CommonExecutorUTProxy commonExecutorUtProxy = new CommonExecutorUTProxy(); //todo
_updatableContainer.AddUpdatableElement(commonExecutorUtProxy);
TerrainTextureFormatTransformator transformator =
new TerrainTextureFormatTransformator(commonExecutorUtProxy);
var globalHeightTexture = transformator.EncodedHeightTextureToPlain(new TextureWithSize()
{
Size = new IntVector2(3600, 3600),
Texture = rgbaMainTexture
});
/// /// VISIBILITY TEXTURE
var visibilityTextureSideLength = 16;
var visibilityTexture = new Texture2D(visibilityTextureSideLength, visibilityTextureSideLength,
TextureFormat.RFloat, false);
visibilityTexture.filterMode = FilterMode.Point;
var visibilityTextureProcessorProxy =
new Ring1VisibilityTextureProcessorUTProxy(new Ring1VisibilityTextureProcessor(visibilityTexture));
_updatableContainer.AddUpdatableElement(visibilityTextureProcessorProxy);
var visibilityTextureChangeGrabber = new Ring1VisibilityTextureChangeGrabber();
var terrainParentGameObject = new GameObject("TerrainParent");
var unityCoordsCalculator = new UnityCoordsCalculator(new Vector2(24 * 240 * 2, 24 * 240 * 2));
var orderGrabber = new Ring1PaintingOrderGrabber();
var painterProxy = new RingTerrainPainterUTProxy(new RingTerrainPainter());
_updatableContainer.AddUpdatableElement(painterProxy);
painterProxy.Update();
var mainRespondingProxy = new Ring1NodeEventMainRespondingProxy(new Ring1NodeEventMainResponder());
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = mainRespondingProxy,
EveryPostAction =
() =>
{
var delta = visibilityTextureChangeGrabber.RetriveVisibilityChanges();
if (delta.AnyChange)
{
var visibilityTextureChagnes = visibilityTextureChangeGrabber.RetriveVisibilityChanges();
visibilityTextureProcessorProxy.AddOrder(visibilityTextureChagnes);
}
if (orderGrabber.IsAnyOrder)
{
painterProxy.AddOrder(orderGrabber.RetriveOrderAndClear());
}
}
});
UTTextureRendererProxy textureRendererProxy = new UTTextureRendererProxy(new TextureRendererService(
new MultistepTextureRenderer(ContainerGameObject), new TextureRendererServiceConfiguration()
{
StepSize = new Vector2(500, 500)
}));
_updatableContainer.AddUpdatableElement(textureRendererProxy);
UnityThreadComputeShaderExecutorObject computeShaderExecutorObject =
new UnityThreadComputeShaderExecutorObject();
_updatableContainer.AddUpdatableElement(computeShaderExecutorObject);
_updatableContainer.AddUpdatableElement(commonExecutorUtProxy);
TerrainDetailGenerator terrainDetailGenerator =
CreateTerrainDetailGenerator(
globalHeightTexture, textureRendererProxy, commonExecutorUtProxy, computeShaderExecutorObject,
ContainerGameObject);
TerrainDetailProvider terrainDetailProvider =
CreateTerrainDetailProvider(terrainDetailGenerator);
var terrainShapeDb = FETerrainShapeDbInitialization.CreateTerrainShapeDb(terrainDetailProvider, commonExecutorUtProxy
, new TerrainDetailAlignmentCalculator(240), false, false, false, null);
TerrainShapeDbProxy terrainShapeDbProxy = new TerrainShapeDbProxy(terrainShapeDb);
terrainDetailGenerator.SetBaseTerrainDetailProvider(BaseTerrainDetailProvider.CreateFrom(terrainShapeDb));
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = terrainShapeDbProxy
});
var meshGeneratorProxy = new MeshGeneratorUTProxy(new MeshGeneratorService());
_updatableContainer.AddUpdatableElement(meshGeneratorProxy);
_stainTerrainResourceCreatorUtProxy =
new StainTerrainResourceCreatorUTProxy(new StainTerrainResourceCreator());
_updatableContainer.AddUpdatableElement(_stainTerrainResourceCreatorUtProxy);
var stainTerrainServiceProxy = new StainTerrainServiceProxy(
new StainTerrainService(
new ComputationStainTerrainResourceGenerator(
new StainTerrainResourceComposer(
_stainTerrainResourceCreatorUtProxy
),
new StainTerrainArrayMelder(),
new DummyStainTerrainArrayFromBiomesGenerator(
new DebugBiomeContainerGenerator().GenerateBiomesContainer(
new BiomesContainerConfiguration()),
new StainTerrainArrayFromBiomesGeneratorConfiguration()
)),
new MyRectangle(0, 0, 24 * 240 * 2, 24 * 240 * 2)));
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = stainTerrainServiceProxy
});
var gRing1NodeTerrainCreator = new GRing1NodeTerrainCreator(
orderGrabber,
terrainParentGameObject,
meshGeneratorProxy,
terrainShapeDbProxy,
stainTerrainServiceProxy,
unityCoordsCalculator,
null,
null,
new GRingGroundShapeProviderConfiguration(),
new GRingTerrainMeshProviderConfiguration());
var gRing2NodeTerrainCreator = new GRing2NodeTerrainCreator(
orderGrabber,
terrainParentGameObject,
meshGeneratorProxy,
terrainShapeDbProxy,
unityCoordsCalculator,
new GRing2PatchesCreatorProxy(CreateRing2PatchesCreator()),
null,
null,
new GRingGroundShapeProviderConfiguration(),
new GRingTerrainMeshProviderConfiguration());
UTRing2PlateStamperProxy stamperProxy = new UTRing2PlateStamperProxy(
new Ring2PlateStamper(new Ring2PlateStamperConfiguration()
{
PlateStampPixelsPerUnit = new Dictionary <int, float>()
}, ContainerGameObject));
_updatableContainer.AddUpdatableElement(stamperProxy);
Ring2PatchStamplingOverseerFinalizer patchStamper =
new Ring2PatchStamplingOverseerFinalizer(stamperProxy, textureRendererProxy, commonExecutorUtProxy);
var gStampedRing2NodeTerrainCreator = new GStampedRing2NodeTerrainCreator(
orderGrabber,
terrainParentGameObject,
meshGeneratorProxy,
terrainShapeDbProxy,
unityCoordsCalculator,
new GRing2PatchesCreatorProxy(CreateRing2PatchesCreator()),
patchStamper,
null,
null,
new GRingGroundShapeProviderConfiguration(),
new GRingTerrainMeshProviderConfiguration());
var subCreator = new SupremeGRingNodeTerrainCreator(new List <NewListenersCreatorWithLimitation>()
{
//new NewListenersCreatorWithMaximumLod()
//{
// Creator = gRing1NodeTerrainCreator,
// MaximumLod = new FlatLod(6)
//},
new NewListenersCreatorWithLimitation()
{
Creator = new GVoidNodeTerrainCreator(),
MaximumLod = new FlatLod(6)
},
//new NewListenersCreatorWithMaximumLod()
//{
// Creator = gRing2NodeTerrainCreator,
// MaximumLod = new FlatLod(8)
//}
new NewListenersCreatorWithLimitation()
{
Creator = gStampedRing2NodeTerrainCreator,
MaximumLod = new FlatLod(9)
}
});
var eventCollector = new Ring1NodeEventCollector(
new DynamicFlatLodGRingNodeTerrainCreator(subCreator, new FlatLodCalculator(unityCoordsCalculator)));
_ring1TreeProxy = new Ring1TreeProxy(_ring1Tree);
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = _ring1TreeProxy,
EveryPostAction =
() =>
{
if (eventCollector.Any)
{
mainRespondingProxy.AddOrder(eventCollector.RetriveOrderAndClear());
}
}
});
var baseQuadSideLength = 90f;
StartThreading(_otherThreadActionPairs);
_ring1TreeProxy.CreateHeightmap(new Ring1Tree.RootNodeCreationParameters()
{
UnityCoordsCalculator = unityCoordsCalculator,
NodeListener = eventCollector,
PrecisionDistances =
new Dictionary <float, int>
{
//{4f * 50f/3f, 9},
//{4f * 50f/2f, 8},
{ CalculatePrecisionDistance(baseQuadSideLength, 2, 1), 7 },
{ 6.5f * 50f, 6 },
{ 20 * 50f, 5 },
{ 40 * 50f, 4 },
{ 50 * 50f, 3 },
{ 100 * 50f, 2 },
{ 200 * 50f, 1 }
},
InitialCameraPosition = Vector3.zero,
});
}
public void Start()
{
TaskUtils.SetGlobalMultithreading(true);
_computeShaderExecutorObject = new UnityThreadComputeShaderExecutorObject();
_commonExecutorUtProxy = new CommonExecutorUTProxy();
_utTextureRendererProxy = new UTTextureRendererProxy(new TextureRendererService(
new MultistepTextureRenderer(ContainerGameObject), new TextureRendererServiceConfiguration()
{
StepSize = new Vector2(500, 500)
}));
var rgbaMainTexture = SavingFileManager.LoadPngTextureFromFile(@"C:\inz\cont\n49_e019_1arc_v3.png", 3600,
3600,
TextureFormat.ARGB32, true, false);
TerrainTextureFormatTransformator transformator =
new TerrainTextureFormatTransformator(_commonExecutorUtProxy);
transformator.EncodedHeightTextureToPlainAsync(new TextureWithSize()
{
Size = new IntVector2(3600, 3600),
Texture = rgbaMainTexture
}).ContinueWith(x =>
{
var mainTexture = x.Result;
TerrainDetailGenerator generator = CreateTerrainDetailGenerator(new TextureWithSize()
{
Size = new IntVector2(3600, 3600),
Texture = mainTexture
});
TerrainDetailProvider terrainDetailProvider = CreateTerrainDetailProvider(generator);
var db = FETerrainShapeDbInitialization.CreateTerrainShapeDb(terrainDetailProvider, _commonExecutorUtProxy,
new TerrainDetailAlignmentCalculator(240), false, false, false, null);
MyRectangle queryArea = null;
if (_terrainResolution == TerrainCardinalResolution.MIN_RESOLUTION)
{
queryArea = new MyRectangle(0, 0, 24 * 240, 24 * 240);
}
else if (_terrainResolution == TerrainCardinalResolution.MID_RESOLUTION)
{
queryArea = new MyRectangle(3 * 240, 3 * 240, 3 * 240, 3 * 240);
}
else
{
queryArea =
new MyRectangle(5 * 0.375f * 240, 5 * 0.375f * 240, 0.375f * 240, 0.375f * 240);
}
var outputOfGeneration = db.QueryAsync(new TerrainDescriptionQuery()
{
QueryArea = queryArea,
RequestedElementDetails = new List <TerrainDescriptionQueryElementDetail>()
{
new TerrainDescriptionQueryElementDetail()
{
Resolution = _terrainResolution.LowerResolution,
Type = TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY
},
new TerrainDescriptionQueryElementDetail()
{
Resolution = _terrainResolution,
Type = TerrainDescriptionElementTypeEnum.NORMAL_ARRAY
},
}
});
outputOfGeneration.ContinueWith(c =>
{
GeneratedTerrainElements elem = new GeneratedTerrainElements();
elem.HeightElement = c.Result.GetElementOfType(TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY);
elem.NormalElement = c.Result.GetElementOfType(TerrainDescriptionElementTypeEnum.NORMAL_ARRAY);
_generatedElements.Add(elem);
}).ContinueWith(q =>
{
Debug.Log("Error: Executing task");
Debug.Log("Error descr is " + q.Exception);
}, TaskContinuationOptions.OnlyOnFaulted
);
});
}
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;
}
});
}
// Use this for initialization
void Start()
{
_updatableContainer = new UpdatableContainer();
TaskUtils.SetGlobalMultithreading(true);
int minSubmapWidth = 256; //(int)Math.Floor((double)filePixelWidth/subTerrainCount)-1 ;
var ring1Array = SavingFileManager.LoadFromFile("map.dat", 2048, 2048);
ring1Array = BasicHeightmapModifier.Multiply(1000, ring1Array);
_ring1Tree = new Ring1Tree();
//////////////////
var tessalationRequirementTextureGenerator = new TessalationRequirementTextureGenerator();
var tessalationReqTexture =
tessalationRequirementTextureGenerator.GenerateTessalationRequirementTexture(ring1Array, 64);
var heightmapBundle = SavingFileManager.LoadHeightmapBundlesFromFiles("heightmapBundle", 4, 2048);
var submapTextures = new Ring1SubmapTextures(heightmapBundle, tessalationReqTexture);
/// /// VISIBILITY TEXTURE
var visibilityTextureSideLength = 16;
var visibilityTexture = new Texture2D(visibilityTextureSideLength, visibilityTextureSideLength,
TextureFormat.RFloat, false);
visibilityTexture.filterMode = FilterMode.Point;
var visibilityTextureProcessorProxy =
new Ring1VisibilityTextureProcessorUTProxy(new Ring1VisibilityTextureProcessor(visibilityTexture));
_updatableContainer.AddUpdatableElement(visibilityTextureProcessorProxy);
var visibilityTextureChangeGrabber = new Ring1VisibilityTextureChangeGrabber();
var terrainParentGameObject = new GameObject("TerrainParent");
var unityCoordsCalculator = new UnityCoordsCalculator(new Vector2(256, 256));
var orderGrabber = new Ring1PaintingOrderGrabber();
var painterProxy = new RingTerrainPainterUTProxy(new RingTerrainPainter());
_updatableContainer.AddUpdatableElement(painterProxy);
painterProxy.Update();
var mainRespondingProxy = new Ring1NodeEventMainRespondingProxy(new Ring1NodeEventMainResponder());
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = mainRespondingProxy,
EveryPostAction =
() =>
{
var delta = visibilityTextureChangeGrabber.RetriveVisibilityChanges();
if (delta.AnyChange)
{
var visibilityTextureChagnes = visibilityTextureChangeGrabber.RetriveVisibilityChanges();
visibilityTextureProcessorProxy.AddOrder(visibilityTextureChagnes);
}
if (orderGrabber.IsAnyOrder)
{
painterProxy.AddOrder(orderGrabber.RetriveOrderAndClear());
}
}
});
var commonExecutor = new CommonExecutorUTProxy();
_updatableContainer.AddUpdatableElement(commonExecutor);
TerrainShapeDbProxy terrainShapeDbProxy = new TerrainShapeDbProxy(
FETerrainShapeDbInitialization.CreateTerrainShapeDb(null /*todo here*/, commonExecutor, new TerrainDetailAlignmentCalculator(240),
false, false, false, null));
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = terrainShapeDbProxy
});
var meshGeneratorProxy = new MeshGeneratorUTProxy(new MeshGeneratorService());
_updatableContainer.AddUpdatableElement(meshGeneratorProxy);
//var eventCollector = new Ring1NodeEventCollector((node) =>
// new Ring1NodeDirectHeightTerrain(
// node,
// visibilityTextureChangeGrabber,
// visibilityTexture,
// terrainParentGameObject,
// unityCoordsCalculator,
// orderGrabber,
// terrainShapeDbProxy,
// ring1Array,
// meshGeneratorProxy));
var eventCollector = new Ring1NodeEventCollector(new FromLambdaListenersCreator((node) =>
new Ring1ListenerToGRingListener(
new Ring1NodeShaderHeightTerrain(
node,
visibilityTextureChangeGrabber,
visibilityTexture,
terrainParentGameObject,
unityCoordsCalculator,
orderGrabber,
terrainShapeDbProxy,
meshGeneratorProxy,
null)))); //todo if you want this to work
var ring1Proxy = new Ring1TreeProxy(_ring1Tree);
_otherThreadActionPairs.Add(new OtherThreadProxyAndActionPair()
{
Proxy = ring1Proxy,
EveryPostAction =
() =>
{
if (eventCollector.Any)
{
mainRespondingProxy.AddOrder(eventCollector.RetriveOrderAndClear());
}
}
});
StartThreading();
ring1Proxy.CreateHeightmap(
new Ring1Tree.RootNodeCreationParameters()
{
UnityCoordsCalculator = unityCoordsCalculator,
NodeListener = eventCollector,
PrecisionDistances = Ring1TestDefaults.PrecisionDistances,
InitialCameraPosition = Vector3.zero,
});
}
