private TerrainDetailGenerator CreateTerrainDetailGenerator(
Texture mainTexture,
UTTextureRendererProxy utTextureRendererProxy,
CommonExecutorUTProxy commonExecutorUtProxy,
UnityThreadComputeShaderExecutorObject computeShaderExecutorObject,
ComputeShaderContainerGameObject containerGameObject)
{
var featureAppliers = new List <RankedTerrainFeatureApplier>();
if (_configuration.EngraveTerrainFeatures)
{
featureAppliers.AddRange(FinalTerrainFeatureAppliers.CreateFeatureAppliers(
utTextureRendererProxy, containerGameObject, commonExecutorUtProxy, computeShaderExecutorObject
));
}
if (_configuration.EngraveRoadsInTerrain)
{
featureAppliers.Add(FinalTerrainFeatureAppliers.CreateRoadEngravingApplier(CreateRoadEngravingFeatureApplier()));
}
TerrainDetailGeneratorConfiguration generatorConfiguration =
_configuration.TerrainDetailGeneratorConfiguration;
TextureWithCoords fullFundationData = new TextureWithCoords(new TextureWithSize()
{
Texture = mainTexture,
Size = new IntVector2(mainTexture.width, mainTexture.height)
}, new MyRectangle(0, 0, 3601 * 24, 3601 * 24));
TerrainDetailGenerator generator = new TerrainDetailGenerator(generatorConfiguration,
utTextureRendererProxy, fullFundationData, featureAppliers, commonExecutorUtProxy);
return(generator);
}
public static TerrainDetailGenerator CreateTerrainDetailGenerator(
Texture mainTexture, UTTextureRendererProxy utTextureRendererProxy,
CommonExecutorUTProxy commonExecutorUtProxy,
UnityThreadComputeShaderExecutorObject computeShaderExecutorObject,
ComputeShaderContainerGameObject containerGameObject)
{
var featureAppliers =
TerrainDetailProviderDebugUtils.CreateFeatureAppliers(utTextureRendererProxy, containerGameObject,
commonExecutorUtProxy, computeShaderExecutorObject);
TerrainDetailGeneratorConfiguration generatorConfiguration = new TerrainDetailGeneratorConfiguration()
{
TerrainDetailImageSideDisjointResolution = 240
};
TextureWithCoords fullFundationData = new TextureWithCoords(new TextureWithSize()
{
Texture = mainTexture,
Size = new IntVector2(mainTexture.width, mainTexture.height)
}, new MyRectangle(0, 0, 3601 * 24, 3601 * 24));
TerrainDetailGenerator generator =
new TerrainDetailGenerator(generatorConfiguration, utTextureRendererProxy, fullFundationData,
featureAppliers, commonExecutorUtProxy);
return(generator);
}
public async Task <TextureWithCoords> ApplyFeatureAsync(TextureWithCoords texture,
TerrainCardinalResolution resolution, bool canMultistep)
{
var configuration = _configurations[resolution];
var detailedHeightmapArray = await TaskUtils
.RunInThreadPool(
() =>
{
var creator = new DiamondSquareCreator(_randomProviderGenerator.GetRandom());
var initialArray = creator.CreateDiamondSquareNoiseArray(
texture.TextureSize,
configuration.DiamondSquareWorkingArrayLength);
return(initialArray);
});
var detailedTexture = await _commonExecutor
.AddAction(() => HeightmapUtils.CreateTextureFromHeightmap(detailedHeightmapArray));
UniformsPack pack = new UniformsPack();
pack.SetTexture("_Texture1", texture.Texture);
pack.SetTexture("_Texture2", detailedTexture);
pack.SetUniform("_Texture2Weight", configuration.DiamondSquareWeight);
var renderCoords = new MyRectangle(0, 0, 1, 1);
var outTextureSize = texture.TextureSize;
ConventionalTextureInfo outTextureInfo =
new ConventionalTextureInfo(outTextureSize.X, outTextureSize.Y, TextureFormat.ARGB32, true);
TextureRenderingTemplate template = new TextureRenderingTemplate()
{
CanMultistep = canMultistep,
Coords = renderCoords,
OutTextureInfo = outTextureInfo,
RenderTextureFormat = RenderTextureFormat.RFloat,
ShaderName = "Custom/TerrainCreation/DiamondSquareTextureAddingPlain",
UniformPack = pack,
CreateTexture2D = false
};
var renderedTexture = await _rendererProxy.AddOrder(template);
await _commonExecutor.AddAction(() => GameObject.Destroy(detailedTexture));
return(new TextureWithCoords(sizedTexture: new TextureWithSize()
{
Texture = renderedTexture,
Size = texture.TextureSize
}, coords: texture.Coords));
}
public async Task <TextureWithCoords> ApplyFeatureAsync(TextureWithCoords inputTexture,
TerrainCardinalResolution resolution, bool CanMultistep = false)
{
if (!TaskUtils.GetGlobalMultithreading())
{
Preconditions.Assert(inputTexture.Texture.width == inputTexture.Texture.height,
"Only square inputTextures are supported");
}
UniformsPack pack = new UniformsPack();
await _commonExecutor.AddAction(() => inputTexture.Texture.filterMode = FilterMode.Point);
pack.SetTexture("_SourceTexture", inputTexture.Texture);
pack.SetUniform("_InputGlobalCoords", inputTexture.Coords.ToVector4());
pack.SetUniform("_QuantingResolution", inputTexture.TextureSize.X - 1);
var configuration = _configurations[resolution];
pack.SetUniform("_DetailResolutionMultiplier", configuration.DetailResolutionMultiplier);
pack.SetUniform("_NoiseStrengthMultiplier", configuration.NoiseStrengthMultiplier);
var renderCoords = new MyRectangle(0, 0, 1, 1);
var outTextureSize = inputTexture.TextureSize;
ConventionalTextureInfo outTextureInfo =
new ConventionalTextureInfo(outTextureSize.X, outTextureSize.Y, TextureFormat.ARGB32, true);
TextureRenderingTemplate template = new TextureRenderingTemplate()
{
CanMultistep = false,
Coords = renderCoords,
OutTextureInfo = outTextureInfo,
RenderTextureFormat = RenderTextureFormat.RFloat,
ShaderName = "Custom/TerrainCreation/NoiseAddingPlain",
UniformPack = pack,
CreateTexture2D = false
};
return(new TextureWithCoords(sizedTexture: new TextureWithSize()
{
Texture = await _rendererProxy.AddOrder(template),
Size = inputTexture.TextureSize
}, coords: inputTexture.Coords));
}
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);
}
private TerrainDetailProvider CreateTerrainDetailProvider(List <RankedTerrainFeatureApplier> featureAppliers,
Texture mainTexture)
{
TerrainDetailGeneratorConfiguration generatorConfiguration = new TerrainDetailGeneratorConfiguration()
{
TerrainDetailImageSideDisjointResolution = 240
};
TextureWithCoords fullFundationData = new TextureWithCoords(new TextureWithSize()
{
Texture = mainTexture,
Size = new IntVector2(mainTexture.width, mainTexture.height)
}, new MyRectangle(0, 0, 3601 * 24, 3601 * 24));
TerrainDetailGenerator generator =
new TerrainDetailGenerator(generatorConfiguration, _utTextureRendererProxy, fullFundationData,
featureAppliers, new CommonExecutorUTProxy());
TerrainDetailProvider provider =
new TerrainDetailProvider(generator, null, new TerrainDetailAlignmentCalculator(240));
generator.SetBaseTerrainDetailProvider(BaseTerrainDetailProvider.CreateFrom(provider));
return(provider);
}
public async Task <TextureWithCoords> ApplyFeatureAsync(TextureWithCoords texture,
TerrainCardinalResolution resolution, bool canMultistep)
{
ComputeShaderParametersContainer parametersContainer = new ComputeShaderParametersContainer();
IntVector2 textureSize = texture.TextureSize;
var heightComputeBuffer = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4,
Type = ComputeBufferType.Default
});
var outRenderTexture = parametersContainer.AddComputeShaderTextureTemplate(
new MyComputeShaderTextureTemplate()
{
Size = textureSize,
Depth = 24,
EnableReadWrite = true,
Format = RenderTextureFormat.RFloat,
TexWrapMode = TextureWrapMode.Clamp,
});
MultistepComputeShader transferComputeShader =
new MultistepComputeShader(_computeShaderContainer.HeightTransferShaderPlain, textureSize);
var textureToBufferKernel = transferComputeShader.AddKernel("CSHeightTransform_InputTextureToBuffer");
var bufferToTextureKernel = transferComputeShader.AddKernel("CSHeightTransform_BufferToOutputTexture");
transferComputeShader.SetGlobalUniform("g_sideLength", textureSize.X);
var inputHeightTexture = parametersContainer.AddExistingComputeShaderTexture(texture.Texture);
transferComputeShader.SetTexture("InputHeightTexture", inputHeightTexture,
new List <MyKernelHandle>()
{
textureToBufferKernel
});
transferComputeShader.SetTexture("OutputHeightTexture", outRenderTexture,
new List <MyKernelHandle>()
{
bufferToTextureKernel
});
transferComputeShader.SetBuffer("HeightBuffer", heightComputeBuffer,
new List <MyKernelHandle>()
{
textureToBufferKernel, bufferToTextureKernel
});
//////////////////////////////
MultistepComputeShader thermalErosionComputeShader =
new MultistepComputeShader(_computeShaderContainer.TweakedThermalErosionShader, textureSize);
var kernel1 = thermalErosionComputeShader.AddKernel("CSTweakedThermal_Precalculation");
var kernel2 = thermalErosionComputeShader.AddKernel("CSTweakedThermal_Erosion");
var configuration = _configurations[resolution];
thermalErosionComputeShader.SetGlobalUniform("g_tParam", configuration.TParam);
thermalErosionComputeShader.SetGlobalUniform("g_cParam", configuration.CParam);
thermalErosionComputeShader.SetGlobalUniform("g_sideLength", textureSize.X);
thermalErosionComputeShader.SetTexture("InputHeightTexture", inputHeightTexture,
new List <MyKernelHandle>()
{
kernel1
});
thermalErosionComputeShader.SetBuffer("HeightBuffer0", heightComputeBuffer,
new List <MyKernelHandle>()
{
kernel1, kernel2
});
var MyHeightBuffer1 = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4,
Type = ComputeBufferType.Default
});
thermalErosionComputeShader.SetBuffer("HeightBuffer1", MyHeightBuffer1,
new List <MyKernelHandle>()
{
kernel1, kernel2
});
var MyMidTextureBuffer = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4 * 2,
Type = ComputeBufferType.Default
});
thermalErosionComputeShader.SetBuffer("MidTextureBuffer", MyMidTextureBuffer,
new List <MyKernelHandle>()
{
kernel1, kernel2
});
var outParameters = new ComputeBufferRequestedOutParameters(new List <MyComputeShaderTextureId>()
{
outRenderTexture
});
await _shaderExecutorObject.AddOrder(new ComputeShaderOrder()
{
OutParameters = outParameters,
ParametersContainer = parametersContainer,
WorkPacks = new List <ComputeShaderWorkPack>()
{
new ComputeShaderWorkPack()
{
Shader = transferComputeShader,
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = 1,
KernelHandles = new List <MyKernelHandle>()
{
textureToBufferKernel
}
}
}
},
new ComputeShaderWorkPack()
{
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = 30,
KernelHandles = new List <MyKernelHandle>()
{
kernel1, kernel2
}
},
},
Shader = thermalErosionComputeShader
},
new ComputeShaderWorkPack()
{
Shader = transferComputeShader,
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = 1,
KernelHandles = new List <MyKernelHandle>()
{
bufferToTextureKernel
}
}
}
},
}
});
return(new TextureWithCoords(sizedTexture: new TextureWithSize()
{
Texture = outParameters.RetriveTexture(outRenderTexture),
Size = texture.TextureSize
}, coords: texture.Coords));
}
public async Task <TextureWithCoords> ApplyFeatureAsync(TextureWithCoords texture,
TerrainCardinalResolution resolution, bool canMultistep)
{
ComputeShaderParametersContainer parametersContainer = new ComputeShaderParametersContainer();
IntVector2 textureSize = texture.TextureSize;
var heightComputeBuffer = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4,
Type = ComputeBufferType.Default
});
var outRenderTexture = parametersContainer.AddComputeShaderTextureTemplate(
new MyComputeShaderTextureTemplate()
{
Depth = 24,
EnableReadWrite = true,
Format = RenderTextureFormat.RFloat,
Size = textureSize,
TexWrapMode = TextureWrapMode.Clamp
});
MultistepComputeShader transferComputeShader =
new MultistepComputeShader(_computeShaderContainer.HeightTransferShaderPlain, textureSize);
var textureToBufferKernel = transferComputeShader.AddKernel("CSHeightTransform_InputTextureToBuffer");
var bufferToTextureKernel = transferComputeShader.AddKernel("CSHeightTransform_BufferToOutputTexture");
transferComputeShader.SetGlobalUniform("g_sideLength", textureSize.X);
var transferInputHeightTexture = parametersContainer.AddExistingComputeShaderTexture(texture.Texture);
transferComputeShader.SetTexture("InputHeightTexture", transferInputHeightTexture,
new List <MyKernelHandle>()
{
textureToBufferKernel
});
transferComputeShader.SetTexture("OutputHeightTexture", outRenderTexture,
new List <MyKernelHandle>()
{
bufferToTextureKernel
});
transferComputeShader.SetBuffer("HeightBuffer", heightComputeBuffer,
new List <MyKernelHandle>()
{
textureToBufferKernel, bufferToTextureKernel
});
//////////////////////////////
//var configuration =
// new HydraulicEroderConfiguration()
// {
// StepCount = 20,
// kr_ConstantWaterAddition = 0.000002f, // 0.0001f,
// ks_GroundToSedimentFactor = 1f,
// ke_WaterEvaporationFactor = 0.05f,
// kc_MaxSedimentationFactor = 0.8f,
// };
var configuration = _configurations[resolution];
MultistepComputeShader computeShader =
new MultistepComputeShader(_computeShaderContainer.HydraulicErosionShader, textureSize);
var kernel_water = computeShader.AddKernel("CSHydraulicErosion_Water");
var kernel_erostion = computeShader.AddKernel("CSHydraulicErosion_Erosion");
var kernel_deltaSum = computeShader.AddKernel("CSHydraulicErosion_DeltaSum");
var kernel_clearDelta = computeShader.AddKernel("CSHydraulicErosion_ClearDelta");
var kernel_evaporation = computeShader.AddKernel("CSHydraulicErosion_Evaporation");
var kernel_sedimentationToGround = computeShader.AddKernel("CSHydraulicErosion_SedimentationToGround");
computeShader.SetGlobalUniform("g_sideLength", textureSize.X);
computeShader.SetGlobalUniform("g_krParam", configuration.kr_ConstantWaterAddition);
computeShader.SetGlobalUniform("g_ksParam", configuration.ks_GroundToSedimentFactor);
computeShader.SetGlobalUniform("g_keParam", configuration.ke_WaterEvaporationFactor);
computeShader.SetGlobalUniform("g_kcParam", configuration.kc_MaxSedimentationFactor);
var allKernels =
new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_deltaSum,
kernel_clearDelta,
kernel_evaporation,
kernel_sedimentationToGround
};
computeShader.SetBuffer("HeightMap", heightComputeBuffer,
new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_evaporation,
kernel_sedimentationToGround
});
var waterMap = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4,
Type = ComputeBufferType.Default
});
computeShader.SetBuffer("WaterMap", waterMap,
new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_deltaSum,
kernel_evaporation,
});
var deltaBuffer = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4 * 2 * 9,
Type = ComputeBufferType.Default
});
computeShader.SetBuffer("DeltaBuffer", deltaBuffer,
new List <MyKernelHandle>()
{
kernel_erostion,
kernel_deltaSum,
kernel_clearDelta
});
var sedimentMap = parametersContainer.AddComputeBufferTemplate(new MyComputeBufferTemplate()
{
Count = textureSize.X * textureSize.Y,
Stride = 4,
Type = ComputeBufferType.Default
});
computeShader.SetBuffer("SedimentMap", sedimentMap,
new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_deltaSum,
kernel_evaporation,
kernel_sedimentationToGround
});
var debugTexture = parametersContainer.AddComputeShaderTextureTemplate(new MyComputeShaderTextureTemplate()
{
Depth = 24,
EnableReadWrite = true,
Format = RenderTextureFormat.ARGB32,
Size = textureSize,
TexWrapMode = TextureWrapMode.Clamp
});
computeShader.SetTexture("DebugTexture", debugTexture,
new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_deltaSum,
kernel_clearDelta,
kernel_evaporation,
kernel_sedimentationToGround
});
var loopedKernels = new List <MyKernelHandle>()
{
kernel_water,
kernel_erostion,
kernel_deltaSum,
kernel_clearDelta,
kernel_evaporation,
};
ComputeBufferRequestedOutParameters outParameters = new ComputeBufferRequestedOutParameters(
new List <MyComputeShaderTextureId>()
{
outRenderTexture
});
await _shaderExecutorObject.AddOrder(new ComputeShaderOrder()
{
ParametersContainer = parametersContainer,
OutParameters = outParameters,
WorkPacks = new List <ComputeShaderWorkPack>()
{
new ComputeShaderWorkPack()
{
Shader = transferComputeShader,
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = 1,
KernelHandles = new List <MyKernelHandle>()
{
textureToBufferKernel
}
}
}
},
new ComputeShaderWorkPack()
{
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = configuration.StepCount,
KernelHandles = loopedKernels,
},
new ComputeShaderDispatchLoop()
{
DispatchCount = 1,
KernelHandles = new List <MyKernelHandle>()
{
kernel_sedimentationToGround
}
}
},
Shader = computeShader
},
new ComputeShaderWorkPack()
{
Shader = transferComputeShader,
DispatchLoops = new List <ComputeShaderDispatchLoop>()
{
new ComputeShaderDispatchLoop()
{
DispatchCount = 1,
KernelHandles = new List <MyKernelHandle>()
{
bufferToTextureKernel
}
}
}
},
}
});
return(new TextureWithCoords(sizedTexture: new TextureWithSize()
{
Texture = outParameters.RetriveTexture(outRenderTexture),
Size = texture.TextureSize
}, coords: texture.Coords));
}
public async Task <TextureWithCoords> ApplyFeatureAsync(TextureWithCoords texture,
TerrainCardinalResolution resolution,
bool canMultistep)
{
//IntVector2 textureSize = texture.TextureSize;
//var heightComputeBuffer = new ComputeBuffer(textureSize.X * textureSize.Y, 4, ComputeBufferType.Default);
//var outRenderTexture = new RenderTexture(textureSize.X, textureSize.Y, 24, RenderTextureFormat.ARGB32);
//outRenderTexture.enableRandomWrite = true;
//outRenderTexture.Create();
////MultistepComputeShader transferComputeShader =
//// new MultistepComputeShader(_computeShaderContainer.HeightTransferShader, textureSize, 8);
////var textureToBufferKernel = transferComputeShader.AddKernel("CSHeightTransform_InputTextureToBuffer");
////var bufferToTextureKernel = transferComputeShader.AddKernel("CSHeightTransform_BufferToOutputTexture");
////transferComputeShader.SetGlobalUniform("g_sideLength", textureSize.X);
//var inputHeightArray = HeightmapUtils.CreateHeightmapArrayFromTexture(texture.Texture as Texture2D);
//var inExtremes = MyArrayUtils.CalculateExtremes(inputHeightArray.HeightmapAsArray);
//MyArrayUtils.Normalize(inputHeightArray.HeightmapAsArray, inExtremes);
//MyArrayUtils.Multiply(inputHeightArray.HeightmapAsArray, 800f);
////var transferInputHeightTexture = new MyRenderTexture("InputHeightTexture", texture.Texture);
////transferComputeShader.SetTexture(transferInputHeightTexture,
//// new List<MyKernelHandle>() {textureToBufferKernel});
////var transferOutputHeightTexture = new MyRenderTexture("OutputHeightTexture", outRenderTexture);
////transferComputeShader.SetTexture(transferOutputHeightTexture,
//// new List<MyKernelHandle>() {bufferToTextureKernel});
////var transferHeightBuffer = new MyComputeBuffer("HeightBuffer", heightComputeBuffer);
////transferComputeShader.SetBuffer(transferHeightBuffer,
//// new List<MyKernelHandle>() {textureToBufferKernel, bufferToTextureKernel});
////////////////////////////////
//MultistepComputeShader computeShader =
// new MultistepComputeShader(_computeShaderContainer.MeiErosionShader, textureSize, 8);
//var kernel_bufferInitialization = computeShader.AddKernel("CSMei_InitializeBuffers");
//var kernel_waterIncrement = computeShader.AddKernel("CSMei_WaterIncrement");
//var kernel_flowSimulation = computeShader.AddKernel("CSMei_FlowSimulation");
//var kernel_velocityCalculation = computeShader.AddKernel("CSMei_VelocityCalculation");
//var kernel_sedimentCalculation = computeShader.AddKernel("CSMei_SedimentCalculation");
//var kernel_sedimentTransportation = computeShader.AddKernel("CSMei_SedimentTransportation");
//var kernel_evaporation = computeShader.AddKernel("CSMei_Evaporation");
//int StepCount = 50;
//float A_PipeCrossSection = 0.05f;
//float ConstantWaterAdding = 1f / 64;
//float GravityAcceleration = 9.81f;
//float DeltaT = 1f;
//float DepositionConstant = 0.0001f * 12;
//float DissolvingConstant = 0.0001f * 12;
//float EvaporationConstant = 0.05f * 10;
//Vector2 GridSize = new Vector2(1, 1);
//float L_PipeLength = 1;
//float SedimentCapacityConstant = 150;
//computeShader.SetGlobalUniform("g_sideLength", textureSize.X);
//computeShader.SetGlobalUniform("deltaT", DeltaT);
//computeShader.SetGlobalUniform("constantWaterAdding", ConstantWaterAdding);
//computeShader.SetGlobalUniform("A_pipeCrossSection", A_PipeCrossSection);
//computeShader.SetGlobalUniform("l_pipeLength", L_PipeLength);
//computeShader.SetGlobalUniform("g_GravityAcceleration", GravityAcceleration);
//computeShader.SetGlobalUniform("ks_DissolvingConstant", DissolvingConstant);
//computeShader.SetGlobalUniform("kd_DepositionConstant", DepositionConstant);
//computeShader.SetGlobalUniform("ke_EvaporationConstant", EvaporationConstant);
//computeShader.SetGlobalUniform("kc_SedimentCapacityConstant", SedimentCapacityConstant);
//computeShader.SetGlobalUniform("gridSideSize", GridSize.x);
//var allKernels =
// new List<MyKernelHandle>()
// {
// kernel_waterIncrement,
// kernel_flowSimulation,
// kernel_velocityCalculation,
// kernel_sedimentCalculation,
// kernel_sedimentTransportation,
// kernel_evaporation,
// kernel_bufferInitialization
// };
//var heightMap = new MyComputeBuffer("HeightMap", heightComputeBuffer);
//heightMap.SetData(inputHeightArray.HeightmapAsArray); //TODODODOD
//computeShader.SetBuffer(heightMap, allKernels);
//var waterMap = new MyComputeBuffer("WaterMap", textureSize.X * textureSize.Y, 4);
//computeShader.SetBuffer(waterMap, allKernels);
//var waterMap1 = new MyComputeBuffer("WaterMap_1", textureSize.X * textureSize.Y, 4);
//computeShader.SetBuffer(waterMap1, allKernels);
//var waterMap2 = new MyComputeBuffer("WaterMap_2", textureSize.X * textureSize.Y, 4);
//computeShader.SetBuffer(waterMap2, allKernels);
//var fluxMap = new MyComputeBuffer("FluxMap", textureSize.X * textureSize.Y, 4 * 4);
//computeShader.SetBuffer(fluxMap, allKernels);
//var velocityMap = new MyComputeBuffer("VelocityMap", textureSize.X * textureSize.Y, 4 * 2);
//computeShader.SetBuffer(velocityMap, allKernels);
//var sedimentMap = new MyComputeBuffer("SedimentMap", textureSize.X * textureSize.Y, 4);
//computeShader.SetBuffer(sedimentMap, allKernels);
//var sedimentMap1 = new MyComputeBuffer("SedimentMap_1", textureSize.X * textureSize.Y, 4);
//computeShader.SetBuffer(sedimentMap1, allKernels);
//var DebugTexture = new MyRenderTexture("DebugTexture",
// new RenderTexture(textureSize.X, textureSize.Y, 24, RenderTextureFormat.ARGB32), true);
//computeShader.SetTexture(DebugTexture, allKernels);
//var loopedKernels =
// new List<MyKernelHandle>()
// {
// kernel_waterIncrement,
// kernel_flowSimulation,
// kernel_velocityCalculation,
// kernel_sedimentCalculation,
// kernel_sedimentTransportation,
// kernel_evaporation,
// };
//await _shaderExecutorObject.DispatchComputeShader(new ComputeShaderOrder()
//{
// WorkPacks = new List<ComputeShaderWorkPack>()
// {
// //new ComputeShaderWorkPack()
// //{
// // Shader = transferComputeShader,
// // DispatchLoops = new List<ComputeShaderDispatchLoop>()
// // {
// // new ComputeShaderDispatchLoop()
// // {
// // DispatchCount = 1,
// // KernelHandles = new List<MyKernelHandle>() {textureToBufferKernel }
// // }
// // }
// //},
// new ComputeShaderWorkPack()
// {
// DispatchLoops = new List<ComputeShaderDispatchLoop>()
// {
// new ComputeShaderDispatchLoop()
// {
// DispatchCount = StepCount,
// KernelHandles = loopedKernels,
// }
// },
// Shader = computeShader
// },
// //new ComputeShaderWorkPack()
// //{
// // Shader = transferComputeShader,
// // DispatchLoops = new List<ComputeShaderDispatchLoop>()
// // {
// // new ComputeShaderDispatchLoop()
// // {
// // DispatchCount = 1,
// // KernelHandles = new List<MyKernelHandle>() {bufferToTextureKernel}
// // }
// // }
// //},
// }
//});
//var outHeightMap = new float[textureSize.X, textureSize.Y];
//heightMap.GetData(outHeightMap);
//MyArrayUtils.Multiply(outHeightMap, 1/800f);
//MyArrayUtils.DeNormalize(outHeightMap, inExtremes);
//var outTexture = HeightmapUtils.CreateTextureFromHeightmap(new HeightmapArray(outHeightMap));
//return new TextureWithCoords(sizedTexture: new TextureWithSize()
//{
// Texture = outTexture,
// Size = texture.TextureSize
//}, coords: texture.Coords);
throw new NotImplementedException(); //todo
}
