public async Task <TextureWithSize> ExtractMipmapAsync(TextureWithSize inputTexture, RenderTextureFormat format, int mipmapLevelToExtract)
{
var pack = new UniformsPack();
pack.SetTexture("_InputTexture", inputTexture.Texture);
pack.SetUniform("_MipmapLevelToExtract", mipmapLevelToExtract);
var outSize = ComputeMipmappedOutSize(inputTexture.Size, mipmapLevelToExtract);
var newTexture = await _textureRenderer.AddOrder(new TextureRenderingTemplate()
{
CanMultistep = true,
Coords = new MyRectangle(0, 0, 1, 1),
CreateTexture2D = false,
OutTextureInfo = new ConventionalTextureInfo(outSize.X, outSize.Y, TextureFormat.ARGB32, true),
RenderTextureFormat = format,
RenderTextureMipMaps = true,
ShaderName = "Custom/Tool/ExtractMipmap",
UniformPack = pack,
});
return(new TextureWithSize()
{
Texture = newTexture,
Size = outSize
});
}
private async Task <Texture> GenerateTextureWithMipMapsAsync(TextureWithSize tex)
{
IntVector2 outTextureSize = tex.Size;
UniformsPack pack = new UniformsPack();
pack.SetTexture("_SourceTexture", tex.Texture);
ConventionalTextureInfo outTextureInfo =
new ConventionalTextureInfo(outTextureSize.X, outTextureSize.Y, TextureFormat.ARGB32, true);
TextureRenderingTemplate template = new TextureRenderingTemplate()
{
CanMultistep = false,
Coords = new MyRectangle(0, 0, 1, 1),
OutTextureInfo = outTextureInfo,
RenderTextureFormat = RenderTextureFormat.RFloat,
ShaderName = "Custom/TerGen/Cutting",
UniformPack = pack,
CreateTexture2D = false,
RenderTextureMipMaps = true
};
var outTex = await _rendererProxy.AddOrder(template);
await _commonExecutor.AddAction(() => outTex.wrapMode = TextureWrapMode.Clamp);
return(outTex);
}
public async Task SaveNormalDetailElementAsync(string filename, TextureWithSize textureWithSize)
{
var path = _mainDictionaryPath + filename + _extension;
var texture2d = await ChangeNormalTextureToTexture2DAsync(textureWithSize.Texture);
await AsyncFileUtils.SaveTextureToPngFileAsync(path, texture2d, _commonExecutor);
}
public HeightArrayWeldingPack(TextureWithSize weldTexture, HeightArrayWelderProxy welderProxy, CommonExecutorUTProxy commonExecutorUtProxy, bool weldingEnabled)
{
_weldTexture = weldTexture;
_welderProxy = welderProxy;
_commonExecutorUtProxy = commonExecutorUtProxy;
_weldingEnabled = weldingEnabled;
}
private async Task <TerrainDetailElement> GenerateTerrainDetailElementAsync(
MyRectangle queryArea, TerrainCardinalResolution cardinalResolution, CornersMergeStatus requiredMerge,
Func <MyRectangle, TerrainCardinalResolution, TextureWithSize, Task <TextureWithSize> > cornerMergingFunc,
Func <MyRectangle, TerrainCardinalResolution, RequiredCornersMergeStatus, Task <TextureWithSize> > generateElementFunc
)
{
var newTerrainArea = _alignmentCalculator.ComputeAlignedTerrainArea(queryArea, cardinalResolution);
RetrivedTerrainDetailTexture texture = null;
CornersMergeStatus outCornersMergeStatus;
TextureWithSize outTexture = null;
var baseTexture = await generateElementFunc(newTerrainArea, cardinalResolution, RequiredCornersMergeStatus.NOT_MERGED);
if (requiredMerge == CornersMergeStatus.NOT_MERGED)
{
outTexture = baseTexture;
outCornersMergeStatus = CornersMergeStatus.NOT_MERGED;
}
else
{
outTexture = await cornerMergingFunc(queryArea, cardinalResolution, baseTexture);
outCornersMergeStatus = CornersMergeStatus.MERGED;
}
return(new TerrainDetailElement()
{
DetailArea = newTerrainArea,
Resolution = cardinalResolution,
Texture = outTexture,
CornersMergeStatus = outCornersMergeStatus
});
}
public Texture MirrorHeightTexture(TextureWithSize textureWithSize)
{
var renderMaterial = new Material(Shader.Find("Custom/TerGen/MirrorHeightTexture"));
renderMaterial.SetTexture("_SourceTexture", textureWithSize.Texture);
var textureSize = textureWithSize.Size;
return(UltraTextureRenderer.CreateRenderTexture(renderMaterial,
new RenderTextureInfo(textureSize.X, textureSize.Y, RenderTextureFormat.ARGB32, true)));
}
public async Task <Texture> MirrorHeightTextureAsync(TextureWithSize textureWithSize)
{
return(await _commonExecutor.AddAction(() =>
{
var renderMaterial = new Material(Shader.Find("Custom/TerGen/MirrorHeightTexture"));
renderMaterial.SetTexture("_SourceTexture", textureWithSize.Texture);
var textureSize = textureWithSize.Size;
return UltraTextureRenderer.CreateRenderTexture(renderMaterial,
new RenderTextureInfo(textureSize.X, textureSize.Y, RenderTextureFormat.ARGB32, true));
}));
}
public RenderTexture EncodedHeightTextureToPlain(TextureWithSize encodedTexture)
{
var renderMaterial = new Material(Shader.Find("Custom/TerGen/RgbaToRFloat"));
renderMaterial.SetTexture("_SourceTexture", encodedTexture.Texture);
var textureSize = encodedTexture.Size;
var renderTextureInfo = new RenderTextureInfo(textureSize.X, textureSize.Y, RenderTextureFormat.RFloat, true);
var tex = UltraTextureRenderer.CreateRenderTexture(renderMaterial, renderTextureInfo);
return(tex);
}
private async Task <Texture> CreateGenerateAndGenerateTexture(List <RankedTerrainFeatureApplier> featureAppliers,
TextureWithSize globalHeightTexture)
{
var provider = CreateTerrainDetailProvider(featureAppliers, globalHeightTexture);
MyRectangle queryArea = new MyRectangle(0, 0, 24 * 240, 24 * 240);
var resolution = TerrainCardinalResolution.MIN_RESOLUTION;
var outTex = (await provider.GenerateHeightDetailElementAsync(queryArea, resolution, CornersMergeStatus.NOT_MERGED)).Texture;
return(outTex.Texture);
}
public async Task <Texture2D> PlainToEncodedHeightTextureAsync(TextureWithSize plainTexture)
{
return(await _commonExecutor.AddAction(() =>
{
var renderMaterial = new Material(Shader.Find("Custom/TerGen/RFloatToRgba"));
renderMaterial.SetTexture("_SourceTexture", plainTexture.Texture);
var textureSize = plainTexture.Size;
var renderTextureInfo = new RenderTextureInfo(textureSize.X, textureSize.Y, RenderTextureFormat.ARGB32);
ConventionalTextureInfo outTextureinfo =
new ConventionalTextureInfo(textureSize.X, textureSize.Y, TextureFormat.ARGB32, false);
return UltraTextureRenderer.RenderTextureAtOnce(renderMaterial, renderTextureInfo, outTextureinfo);
}));
}
private async Task <TextureWithSize> CreateOutputTexture(TextureWithSize baseTexture)
{
var newTextureTemplate = new MyRenderTextureTemplate(baseTexture.Size.X, baseTexture.Size.Y, RenderTextureFormat.RFloat, true, FilterMode.Point);
newTextureTemplate.wrapMode = TextureWrapMode.Clamp;
newTextureTemplate.SourceTexture = baseTexture.Texture;
var newTexture = await _textureConciever.ConcieveRenderTextureAsync(newTextureTemplate);
return(new TextureWithSize()
{
Size = baseTexture.Size,
Texture = newTexture
});
}
public void CreateTerrainObject(TextureWithSize textureWithSize, Vector2 startPosition)
{
var go = GameObject.CreatePrimitive(PrimitiveType.Plane);
go.GetComponent <MeshFilter>().mesh = PlaneGenerator.CreateFlatPlaneMesh(241, 241);
var material = new Material(Shader.Find("Custom/Debug/SimpleTerrain"));
material.SetTexture("_HeightmapTex", textureWithSize.Texture);
material.SetFloat("_HeightmapTexWidth", 241);
go.GetComponent <MeshRenderer>().material = material;
go.transform.localPosition = new Vector3(startPosition.x, 0, startPosition.y);
go.transform.localScale = new Vector3(90, 10, 90);
go.name = $"TerrainAt" + startPosition;
}
public DebugFlatTerrainShapeDb(UTTextureRendererProxy textureRenderer)
{
var size = new IntVector2(241, 241);
var tex = new Texture2D(size.X, size.Y, TextureFormat.ARGB32, true, true);
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
tex.SetPixel(x, y, new Color(0, 0, 0, 0));
}
}
tex.Apply();
_blankTexture = new TextureWithSize()
{
Texture = tex,
Size = size
};
var pack = new UniformsPack();
pack.SetTexture("_HeightmapTex", tex);
pack.SetUniform("_HeightMultiplier", 80);
ConventionalTextureInfo outTextureInfo =
new ConventionalTextureInfo(size.X, size.Y, TextureFormat.ARGB32, true);
var renderCoords = new MyRectangle(0, 0, 1, 1);
TextureRenderingTemplate template = new TextureRenderingTemplate()
{
CanMultistep = false,
Coords = renderCoords,
OutTextureInfo = outTextureInfo,
RenderTextureFormat = RenderTextureFormat.ARGB32,
ShaderName = "Custom/Terrain/NormalmapGenerator",
UniformPack = pack,
CreateTexture2D = false
};
var outNormalTex = textureRenderer.AddOrder(template).Result;
_normalTexture = new TextureWithSize()
{
Size = size,
Texture = outNormalTex
};
}
private TerrainDetailProvider CreateTerrainDetailProvider(List <RankedTerrainFeatureApplier> featureAppliers,
TextureWithSize globalHeightTexture)
{
TerrainDetailGeneratorConfiguration generatorConfiguration = new TerrainDetailGeneratorConfiguration()
{
TerrainDetailImageSideDisjointResolution = 240
};
TextureWithCoords fullFundationData = new TextureWithCoords(sizedTexture: globalHeightTexture,
coords: new MyRectangle(0, 0, 3601 * 24, 3601 * 24));
TerrainDetailGenerator generator =
new TerrainDetailGenerator(generatorConfiguration, _utTextureRendererProxy, fullFundationData,
featureAppliers, _commonExecutor);
TerrainDetailProvider provider =
new TerrainDetailProvider(generator, null, new TerrainDetailAlignmentCalculator(240));
return(provider);
}
public static UpdatedTerrainTextures GenerateDebugUpdatedTerrainTextures()
{
var height = 1;
var heightArray = new float[12, 12];
for (int x = 0; x < 12; x++)
{
for (int y = 0; y < 12; y++)
{
heightArray[x, y] = height;
}
}
var ha = new HeightmapArray(heightArray);
var encodedHeightTex = HeightmapUtils.CreateTextureFromHeightmap(ha);
var transformer = new TerrainTextureFormatTransformator(new CommonExecutorUTProxy());
var plainHeightTex =
transformer.EncodedHeightTextureToPlain(TextureWithSize.FromTex2D(encodedHeightTex));
var normalArray = new Vector3[12, 12];
for (int x = 0; x < 12; x++)
{
for (int y = 0; y < 12; y++)
{
normalArray[x, y] = new Vector3(0.0f, 0.0f, 1.0f).normalized;
}
}
var normalTexture = HeightmapUtils.CreateNormalTexture(normalArray);
return(new UpdatedTerrainTextures()
{
HeightTexture = plainHeightTex,
NormalTexture = normalTexture,
TextureCoords = new MyRectangle(0, 0, 1, 1),
TextureGlobalPosition = new MyRectangle(0, 0, 90, 90),
});
}
public TerrainDetailGenerator CreateTerrainDetailGenerator(TextureWithSize mainTexture)
{
var featureAppliers =
TerrainDetailProviderDebugUtils.CreateFeatureAppliers(_utTextureRendererProxy, ContainerGameObject,
_commonExecutorUtProxy, _computeShaderExecutorObject);
TerrainDetailGeneratorConfiguration generatorConfiguration = new TerrainDetailGeneratorConfiguration()
{
TerrainDetailImageSideDisjointResolution = 240
};
TextureWithCoords fullFundationData = new TextureWithCoords(new TextureWithSize()
{
Texture = mainTexture.Texture,
Size = new IntVector2(mainTexture.Size.X, mainTexture.Size.Y)
}, new MyRectangle(0, 0, 3601 * 24, 3601 * 24));
TerrainDetailGenerator generator =
new TerrainDetailGenerator(generatorConfiguration, _utTextureRendererProxy, fullFundationData,
featureAppliers, _commonExecutorUtProxy);
return(generator);
}
public DebugSlopedTerrainShapeDb(UTTextureRendererProxy textureRenderer)
{
var size = new IntVector2(241, 241);
var tex = new Texture2D(size.X, size.Y, TextureFormat.ARGB32, true, true);
var encodedHeightTex = new Texture2D(size.X, size.Y, TextureFormat.ARGB32, true, true);
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
tex.SetPixel(x, y, new Color(0, 0, 0, 0));
//var distanceToCenter = 1 - (Vector2.Distance(new Vector2(120, 120), new Vector2(x, y)) /
// Mathf.Sqrt(120 * 120)) / 2;
//encodedHeightTex.SetPixel(x, y, HeightColorTransform.EncodeHeight(distanceToCenter / 100));
//var distanceToCenter = Mathf.Clamp01(
// Mathf.Min(
// Mathf.Abs(y - 100) / 50.0f,
// Mathf.Abs(x - 100) / 50.0f)
// ) / 300;
//encodedHeightTex.SetPixel(x, y, HeightColorTransform.EncodeHeight(distanceToCenter));
var heightInUnits = HeightDenormalizer.Default.Normalize(5);
var encodedHeight = HeightColorTransform.EncodeHeight(heightInUnits);
encodedHeightTex.SetPixel(x, y, encodedHeight);
}
}
tex.Apply();
encodedHeightTex.Apply();
_blankTexture = new TextureWithSize()
{
Texture = tex,
Size = size
};
var transformator = new TerrainTextureFormatTransformator(new CommonExecutorUTProxy());
var encodedHeightTexture = new TextureWithSize()
{
Texture = encodedHeightTex,
Size = new IntVector2(241, 241)
};
var plainTex = transformator.EncodedHeightTextureToPlain(encodedHeightTexture);
_heightTexture = new TextureWithSize()
{
Size = new IntVector2(241, 241),
Texture = plainTex
};
var pack = new UniformsPack();
pack.SetTexture("_HeightmapTex", plainTex);
pack.SetUniform("_HeightMultiplier", 80);
ConventionalTextureInfo outTextureInfo =
new ConventionalTextureInfo(size.X, size.Y, TextureFormat.ARGB32, true);
var renderCoords = new MyRectangle(0, 0, 1, 1);
TextureRenderingTemplate template = new TextureRenderingTemplate()
{
CanMultistep = false,
Coords = renderCoords,
OutTextureInfo = outTextureInfo,
RenderTextureFormat = RenderTextureFormat.ARGB32,
ShaderName = "Custom/Terrain/NormalmapGenerator",
UniformPack = pack,
CreateTexture2D = false
};
var outNormalTex = textureRenderer.AddOrder(template).Result;
_normalTexture = new TextureWithSize()
{
Size = size,
Texture = outNormalTex
};
}
private async Task MergeDetailObject(Dictionary <TerrainDetailCorner, TerrainDetailElement> sourceTextures,
TextureWithSize sourceTexture, TextureWithSize outTexture, TerrainDetailCorner activeCorner, TextureWithSize scratchTexture)
{
var uniforms = new UniformsPack();
var cornersPresent = new Vector4();
var cornersMerged = new Vector4();
int activeCornerIndex = 0;
var i = 0;
foreach (var corner in TerrainDetailCorner.OrderedDirections)
{
if (corner == activeCorner)
{
activeCornerIndex = i;
}
if (sourceTextures.ContainsKey(corner))
{
cornersPresent[i] = 10;
if (sourceTextures[corner].CornersMergeStatus == CornersMergeStatus.MERGED)
{
cornersMerged[i] = 10;
}
uniforms.SetTexture("_Corner" + GetCornerTexUniformName(corner) + "Tex", sourceTextures[corner].Texture.Texture);
}
i++;
}
uniforms.SetUniform("_ActiveCornerIndex", activeCornerIndex);
uniforms.SetUniform("_CornersMerged", cornersMerged);
uniforms.SetTexture("_ScratchTex", scratchTexture.Texture);
uniforms.SetUniform("_MergeMargin", _configuration.MergeMarginSize); // todo
await _renderer.AddOrder(new TextureRenderingTemplate()
{
CanMultistep = false,
CreateTexture2D = false,
RenderTextureToModify = scratchTexture.Texture as RenderTexture, // todo
ShaderName = "Custom/TerrainDetailMerger/MergeIntoScratch",
UniformPack = uniforms,
RenderingRectangle = new IntRectangle(0, 0, scratchTexture.Size.X, scratchTexture.Size.Y),
RenderTargetSize = new IntVector2(scratchTexture.Size.X, scratchTexture.Size.Y),
});
IntRectangle renderingRectangle;
if (activeCorner == TerrainDetailCorner.BottomLeft)
{
renderingRectangle = new IntRectangle(0, 0, 121, 121);
}
else if (activeCorner == TerrainDetailCorner.BottomRight)
{
renderingRectangle = new IntRectangle(120, 0, 121, 121);
}
else if (activeCorner == TerrainDetailCorner.TopLeft)
{
renderingRectangle = new IntRectangle(0, 120, 121, 121);
}
else if (activeCorner == TerrainDetailCorner.TopRight)
{
renderingRectangle = new IntRectangle(120, 120, 121, 121);
}
else
{
Preconditions.Fail("Unsupported activeCorner " + activeCorner);
renderingRectangle = new IntRectangle(0, 0, 1, 1);
}
await _renderer.AddOrder(new TextureRenderingTemplate()
{
CanMultistep = false,
CreateTexture2D = false,
RenderTextureToModify = (RenderTexture)outTexture.Texture,
ShaderName = "Custom/TerrainDetailMerger/ScratchToActive",
UniformPack = uniforms,
RenderingRectangle = renderingRectangle,
RenderTargetSize = new IntVector2(241, 241),
});
}
CreateGridBasedMockProvidingFunction(Dictionary <IntVector2, TextureWithSize> terrainDetailForGridElements, TextureWithSize defaultDetail)
{
var copyOfDictionary = terrainDetailForGridElements.ToDictionary(e => e.Key, e => e.Value);
return(CreateSampleMockProvidingFunction((queryArea) =>
{
foreach (var pair in copyOfDictionary)
{
var realPosition = new Vector2(pair.Key.X * 90f, pair.Key.Y * 90f);
if (Math.Abs(queryArea.X - realPosition.x) < 0.0001f && Math.Abs(queryArea.Y - realPosition.y) < 0.0001f)
{
return pair.Value;
}
}
if (defaultDetail == null)
{
Preconditions.Fail("E911 Failed to return detail in " + queryArea);
}
return defaultDetail;
}));
}
public async Task <TextureWithSize> MergeHeightDetailCorners(MyRectangle queryArea,
TerrainCardinalResolution cardinalResolution, TextureWithSize baseTexture)
{
RetriveTerrainDetailProvider();
var griddedTerrainDetail = _alignmentCalculator.GetGriddedTerrainArea(queryArea, cardinalResolution);
var sourceTerrainDetailTasks = new List <TerrainDetailNeighbourhoodDirections>()
{
TerrainDetailNeighbourhoodDirections.Left,
TerrainDetailNeighbourhoodDirections.BottomLeft,
TerrainDetailNeighbourhoodDirections.Bottom,
}.Select(direction => new
{
direction,
alignedPosition = _alignmentCalculator.GetAlignedTerrainArea(griddedTerrainDetail + direction.Movement, cardinalResolution)
})
.Where(p => _alignmentCalculator.AreaInMap(p.alignedPosition))
.ToDictionary(
p => p.direction,
p => _terrainDetailProvider.RetriveTerrainDetailAsync(
TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY, p.alignedPosition, cardinalResolution, RequiredCornersMergeStatus.NOT_IMPORTANT)
);
var sourceTerrainDetails = new Dictionary <TerrainDetailNeighbourhoodDirections, TokenizedTerrainDetailElement>();
foreach (var pair in sourceTerrainDetailTasks)
{
sourceTerrainDetails.Add(pair.Key, (await pair.Value).TokenizedElement);
}
var activeTerrainDetails = new TerrainDetailElement()
{
CornersMergeStatus = CornersMergeStatus.NOT_MERGED,
DetailArea = new MyRectangle(0, 0, 1, 1),
Resolution = cardinalResolution,
Texture = baseTexture
};
var outputTexture = await CreateOutputTexture(baseTexture);
var scratchTextureSize = 121; //todo configurable
var scratchTexture = await _textureConciever.ConcieveRenderTextureAsync(new MyRenderTextureTemplate(scratchTextureSize, scratchTextureSize, RenderTextureFormat.RFloat, false, FilterMode.Point));
var scratchTextureWithSize = new TextureWithSize()
{
Texture = scratchTexture,
Size = new IntVector2(scratchTextureSize, scratchTextureSize)
};
await MergeDetailObject(new Dictionary <TerrainDetailCorner, TerrainDetailElement>()
{
{ TerrainDetailCorner.BottomLeft, activeTerrainDetails },
}, baseTexture, outputTexture, TerrainDetailCorner.TopRight, scratchTextureWithSize);
if (sourceTerrainDetails.ContainsKey(TerrainDetailNeighbourhoodDirections.Left)) // do not merge if one of merging elements was out of map boundaries
{
await MergeDetailObject(new Dictionary <TerrainDetailCorner, TerrainDetailElement>()
{
{ TerrainDetailCorner.BottomRight, activeTerrainDetails },
{ TerrainDetailCorner.BottomLeft, sourceTerrainDetails[TerrainDetailNeighbourhoodDirections.Left].DetailElement },
}, baseTexture, outputTexture, TerrainDetailCorner.TopLeft, scratchTextureWithSize);
}
if (sourceTerrainDetails.ContainsKey(TerrainDetailNeighbourhoodDirections.Left) &&
sourceTerrainDetails.ContainsKey(TerrainDetailNeighbourhoodDirections.BottomLeft) &&
sourceTerrainDetails.ContainsKey(TerrainDetailNeighbourhoodDirections.Bottom))
{
await MergeDetailObject(new Dictionary <TerrainDetailCorner, TerrainDetailElement>()
{
{ TerrainDetailCorner.TopRight, activeTerrainDetails },
{ TerrainDetailCorner.TopLeft, sourceTerrainDetails[TerrainDetailNeighbourhoodDirections.Left].DetailElement },
{ TerrainDetailCorner.BottomLeft, sourceTerrainDetails[TerrainDetailNeighbourhoodDirections.BottomLeft].DetailElement },
{ TerrainDetailCorner.BottomRight, sourceTerrainDetails[TerrainDetailNeighbourhoodDirections.Bottom].DetailElement },
}, baseTexture, outputTexture, TerrainDetailCorner.BottomLeft, scratchTextureWithSize);
}
if (sourceTerrainDetails.ContainsKey(TerrainDetailNeighbourhoodDirections.Bottom))
{
await MergeDetailObject(new Dictionary <TerrainDetailCorner, TerrainDetailElement>()
{
{ TerrainDetailCorner.TopLeft, activeTerrainDetails },
{ TerrainDetailCorner.BottomLeft, sourceTerrainDetails[TerrainDetailNeighbourhoodDirections.Bottom].DetailElement },
}, baseTexture, outputTexture, TerrainDetailCorner.BottomRight, scratchTextureWithSize);
}
await _commonExecutor.AddAction(() => GameObject.Destroy(scratchTexture));
await TaskUtils.WhenAll(sourceTerrainDetails.Values.Select(c => c.Token)
.Select(c => _terrainDetailProvider.RemoveTerrainDetailAsync(c)));
return(outputTexture);
}
public TextureWithCoords(TextureWithSize sizedTexture, MyRectangle coords)
{
_sizedTexture = sizedTexture;
_coords = coords;
}
public void Start()
{
_unityThreadComputeShaderExecutorObject = new UnityThreadComputeShaderExecutorObject();
var globalHeightTexture = SavingFileManager.LoadPngTextureFromFile(@"C:\inz\cont\n49_e019_1arc_v3.png",
3600, 3600,
TextureFormat.ARGB32, true, false);
var sizedGlobalHeightTexture = new TextureWithSize()
{
Size = new IntVector2(3600, 3600),
Texture = globalHeightTexture
};
TaskUtils.SetGlobalMultithreading(true);
_executionThreadProxy = new GenericAsyncExecutionThreadProxy("TerrainProviding");
_executionThreadProxy.StartThreading(() => { });
_executionThreadProxy.PostAction(async() =>
{
InitializeFields();
//var tex0 = await CreateGenerateAndGenerateTexture(new List<RankedTerrainFeatureApplier>()
//{
// new RankedTerrainFeatureApplier()
// {
// Rank = 1,
// Applier = new RandomNoiseTerrainFeatureApplier(_utTextureRendererProxy, _commonExecutor,
// new Dictionary<TerrainCardinalResolution, RandomNoiseTerrainFeatureApplierConfiguration>
// {
// { TerrainCardinalResolution.LOW_RESOLUTION, new RandomNoiseTerrainFeatureApplierConfiguration() { DetailResolutionMultiplier = 1} },
// { TerrainCardinalResolution.MID_RESOLUTION, new RandomNoiseTerrainFeatureApplierConfiguration() {DetailResolutionMultiplier = 8}},
// }),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 2,
// Applier = new DiamondSquareTerrainFeatureApplier(
// new DiamondSquareCreator(_randomProvider), _commonExecutor,
// _utTextureRendererProxy),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 3,
// Applier = new ThermalErosionTerrainFeatureApplier(ContainerGameObject,
// _unityThreadComputeShaderExecutorObject, _commonExecutor),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 4,
// Applier = new HydraulicErosionTerrainFeatureApplier(ContainerGameObject,_unityThreadComputeShaderExecutorObject),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// //new RankedTerrainFeatureApplier()
// //{
// // Rank = 6,
// // Applier = new TweakedThermalErosionTerrainFeatureApplier(ContainerGameObject, _unityThreadComputeShaderExecutorObject),
// // AvalibleResolutions = new List<TerrainCardinalResolution>()
// // {
// // TerrainCardinalResolution.LOW_RESOLUTION,
// // TerrainCardinalResolution.MID_RESOLUTION,
// // TerrainCardinalResolution.MAX_RESOLUTION
// // }
// //}
//}, sizedGlobalHeightTexture);
//var tex1 = await CreateGenerateAndGenerateTexture(new List<RankedTerrainFeatureApplier>()
//{
// new RankedTerrainFeatureApplier()
// {
// Rank = 1,
// Applier = new RandomNoiseTerrainFeatureApplier(_utTextureRendererProxy, _commonExecutor,
// new Dictionary<TerrainCardinalResolution, RandomNoiseTerrainFeatureApplierConfiguration>
// {
// { TerrainCardinalResolution.LOW_RESOLUTION, new RandomNoiseTerrainFeatureApplierConfiguration() { DetailResolutionMultiplier = 1} },
// { TerrainCardinalResolution.MID_RESOLUTION, new RandomNoiseTerrainFeatureApplierConfiguration() {DetailResolutionMultiplier = 8}},
// }),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 2,
// Applier = new DiamondSquareTerrainFeatureApplier(
// new DiamondSquareCreator(_randomProvider), _commonExecutor,
// _utTextureRendererProxy),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 3,
// Applier = new ThermalErosionTerrainFeatureApplier(ContainerGameObject,
// _unityThreadComputeShaderExecutorObject, _commonExecutor),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// new RankedTerrainFeatureApplier()
// {
// Rank = 6,
// Applier = new HydraulicErosionTerrainFeatureApplier(ContainerGameObject,_unityThreadComputeShaderExecutorObject),
// AvalibleResolutions = new List<TerrainCardinalResolution>()
// {
// TerrainCardinalResolution.LOW_RESOLUTION,
// TerrainCardinalResolution.MID_RESOLUTION,
// TerrainCardinalResolution.MAX_RESOLUTION
// }
// },
// //new RankedTerrainFeatureApplier()
// //{
// // Rank = 5,
// // Applier = new TweakedThermalErosionTerrainFeatureApplier(ContainerGameObject, _unityThreadComputeShaderExecutorObject),
// // AvalibleResolutions = new List<TerrainCardinalResolution>()
// // {
// // TerrainCardinalResolution.MID_RESOLUTION,
// // TerrainCardinalResolution.MAX_RESOLUTION
// // }
// //}
//}, sizedGlobalHeightTexture);
//_resultBag.Add(new MyTexturePair()
//{
// Tex0 = tex0,
// Tex1 = tex1
//});
});
}
public async Task <RenderTexture> EncodedHeightTextureToPlainAsync(TextureWithSize encodedTexture)
{
return(await _commonExecutor.AddAction(() => { return EncodedHeightTextureToPlain(encodedTexture); }));
}
