void TerrainDeform(Vector3 position, float craterSizeInMeters)
{
Vector3 terrainPosition = GetRelativeTerrainPositionFromPosition(position, heightmapSize);
TextureSize heightmapCrater = new TextureSize(
(int) (craterSizeInMeters * (heightmapSize.width / terrain.terrainData.size.x)),
(int) (craterSizeInMeters * (heightmapSize.height / terrain.terrainData.size.z)));
int heightmapStartPositionX = (int) (terrainPosition.x - (heightmapCrater.width/2));
int heightmapStartPositionZ = (int) (terrainPosition.z - (heightmapCrater.height/2));
float [,] heights = terrain.terrainData.GetHeights(heightmapStartPositionX, heightmapStartPositionZ, heightmapCrater.width, heightmapCrater.height);
Vector2 circlePos;
float distanceFromCenter;
float depthMultiplier;
float deformationDepth = (craterSizeInMeters / 3.0f) / terrain.terrainData.size.y;
for (int i=0; i<heightmapCrater.height; i++){
for (int j=0; j<heightmapCrater.width;j++){
circlePos.x = (j - (heightmapCrater.width/2) / (heightmapSize.width / terrain.terrainData.size.x));
circlePos.y = (i - (heightmapCrater.height/2) / (heightmapSize.height / terrain.terrainData.size.z));
distanceFromCenter = Mathf.Abs(Mathf.Sqrt(circlePos.x * circlePos.x + circlePos.y * circlePos.y));
if (distanceFromCenter < (craterSizeInMeters / 2.0f)){
depthMultiplier = ((craterSizeInMeters / 2.0f - distanceFromCenter) / craterSizeInMeters / 2.0f) + .1f;
depthMultiplier += Random.value * .1f;
depthMultiplier = Mathf.Clamp(depthMultiplier, 0, 1);
heights[i,j] = Mathf.Clamp(heights[i,j] - deformationDepth * depthMultiplier, 0, 1);
}
}
}
terrain.terrainData.SetHeights(heightmapStartPositionX, heightmapStartPositionZ, heights);
}
//------------------------------------------
public CircleObj GetCircle(TextureSize textureSize)
{
CircleObj obj;
Color color1 = new Color(0f, 0f, 0f, 0.6f);
Color color2 = new Color(0f, 0f, 0f, 0.6f);
Color color3 = new Color(0f, 0f, 0f, 0.6f);
if (++numCircles >= PoolLength)
{
numCircles = 0;
}
obj = circlesPool[numCircles];
obj.Model.renderer.material = materialsPool[numCircles];
obj.Model.renderer.material.mainTexture = texturesPool[textureSize][numCircles];
GenerateTexture(textureSize, numCircles);
color1.r = Random.Range(0f, 1f);
color1.g = Random.Range(0f, 1f);
color1.b = Random.Range(0f, 1f);
color2.r = Random.Range(0f, 1f);
color2.g = Random.Range(0f, 1f);
color2.b = Random.Range(0f, 1f);
color3.r = Random.Range(0f, 1f);
color3.g = Random.Range(0f, 1f);
color3.b = Random.Range(0f, 1f);
obj.Model.renderer.material.SetColor("_Color1", color1);
obj.Model.renderer.material.SetColor("_Color2", color2);
obj.Model.renderer.material.SetColor("_Color3", color3);
return(obj);
}
public static string ChromaScaleDescription(TextureSize size)
{
var chromaConvolver = Renderer.ChromaOffset.IsZero ? null : Renderer.ChromaUpscaler;
var chromastatus = StatusHelpers.ScaleDescription(Renderer.ChromaSize, size, Renderer.ChromaUpscaler, Renderer.ChromaDownscaler, chromaConvolver);
return(chromastatus.AddPrefixToDescription("Chroma: "));
}
/// <summary>
/// Constructs a <see cref="BakeProbeOptions" /> with default values and returns it.
/// </summary>
/// <returns>A <see cref="BakeProbeOptions" /> with default values.</returns>
public static BakeProbeOptions NewDefault()
{
return(new BakeProbeOptions
{
textureSize = TextureSize.NewDefault()
});
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var textureSize = TextureSize.GetFirstValue(payload.Data);
var newTexture = new Texture2D(textureSize, textureSize);
var newPixels = new Color[textureSize * textureSize];
var gradient = ColorGradient.GetFirstValue(payload.Data);
for (int x = 0; x < textureSize; x++)
{
for (int y = 0; y < textureSize; y++)
{
var proportion = x / (float)textureSize;
var color = gradient.Evaluate(proportion);
newPixels[x + y * textureSize] = color;
}
}
newTexture.SetPixels(newPixels);
newTexture.Apply();
TextureTarget.SetValue(newTexture, payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public TextureArraySettings(TextureSize s, Compression c, FilterMode f, int a = 1)
{
textureSize = s;
compression = c;
filterMode = f;
Aniso = a;
}
public override int GetHashCode()
{
return(TextureSize.GetHashCode() ^
Size.GetHashCode() ^
Border.GetHashCode() ^
BackgroundStyle.GetHashCode());
}
public override int GetHashCode()
{
return(base.GetHashCode() ^
Layout.GetHashCode() ^
Texture.GetHashCode() ^
TextureSize.GetHashCode());
}
private void DownscaleAndCalcVar(ITextureFilter input, TextureSize targetSize, out ITextureFilter mean, out ITextureFilter var)
{
var HDownscaler = new Shader(FromFile(SoftDownscaling ? "SoftDownscaler.hlsl" : "./Scalers/Downscaler.hlsl", compilerOptions: "axis = 0;"))
{
Transform = s => new TextureSize(targetSize.Width, s.Height), Format = input.Output.Format
};
var VDownscaler = new Shader(FromFile(SoftDownscaling ? "SoftDownscaler.hlsl" : "./Scalers/Downscaler.hlsl", compilerOptions: "axis = 1;"))
{
Transform = s => new TextureSize(s.Width, targetSize.Height), Format = input.Output.Format
};
var HVar = new Shader(FromFile("DownscaledVarI.hlsl", compilerOptions: "axis = 0;"))
{
Transform = s => new TextureSize(targetSize.Width, s.Height), Format = input.Output.Format
};
var VVar = new Shader(FromFile("DownscaledVarII.hlsl", compilerOptions: "axis = 1;"))
{
Transform = s => new TextureSize(s.Width, targetSize.Height), Format = input.Output.Format
};
var hMean = HDownscaler.ApplyTo(input);
mean = VDownscaler.ApplyTo(hMean);
var hVariance = HVar.ApplyTo(input, hMean);
var = VVar.ApplyTo(hVariance, hMean, mean);
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in Scope.GetEntries(payload.Data))
{
var textureSize = TextureSize.GetValue(entry);
var newTexture = new Texture2D(textureSize, textureSize);
var primaryColor = PrimaryColor.GetValue(entry);
var newPixels = Enumerable.Repeat(primaryColor, textureSize * textureSize).ToArray();
newTexture.SetPixels(newPixels);
newTexture.Apply();
TextureTarget.SetValue(newTexture, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
/// <summary>
/// Get the size of the texture
/// </summary>
/// <param name="size">Texture size</param>
/// <returns>Texture size or zero if invalid</returns>
public static int GetTextureSize(TextureSize size)
{
switch (size)
{
case CTSConstants.TextureSize.Texture_64:
return(64);
case CTSConstants.TextureSize.Texture_128:
return(128);
case CTSConstants.TextureSize.Texture_256:
return(256);
case CTSConstants.TextureSize.Texture_512:
return(512);
case CTSConstants.TextureSize.Texture_1024:
return(1024);
case CTSConstants.TextureSize.Texture_2048:
return(2048);
case CTSConstants.TextureSize.Texture_4096:
return(4096);
case CTSConstants.TextureSize.Texture_8192:
return(8192);
}
//Invalid setting passed in
return(0);
}
public NNedi3HKernelFilter(IShaderFilterSettings <IKernel> settings, IDisposable buffer, int neuronCount, TextureSize textureSize, int[] localWorkSizes,
ITextureFilter <IBaseTexture> inputFilter)
: base(settings, GlobalWorkSizesHelper.Get(textureSize.Height, textureSize.Width, localWorkSizes), localWorkSizes, inputFilter)
{
m_Buffer = buffer;
m_NeuronCount = neuronCount;
m_TextureSize = textureSize;
}
public void ValidTest()
{
TextureSize textureSize = new TextureSize(16, 16);
Size2 value = textureSize;
Assert.AreEqual(value.Width, 16);
Assert.AreEqual(value.Height, 16);
}
//------------------------------------------------------------------------------------------------------------------
private void DrawTextureSizeSelector(ProTexMaterialBinder proTexMaterialBinder)
{
TextureSize textureSize = GetTextureSize(proTexMaterialBinder);
TextureSize newTextureSize = (TextureSize)EditorGUILayout.EnumPopup(textureSize);
if (textureSize != newTextureSize)
{
proTexMaterialBinder.runtimeTextureSize = (int)newTextureSize;
}
}
public static IEnumerable <string> ScaleDescription(TextureSize size)
{
var chromaConvolver = Renderer.ChromaOffset.IsZero ? null : Renderer.ChromaUpscaler;
var chromastatus = StatusHelpers.ScaleDescription(Renderer.ChromaSize, size, Renderer.ChromaUpscaler, Renderer.ChromaDownscaler, chromaConvolver);
var lumastatus = StatusHelpers.ScaleDescription(Renderer.VideoSize, size, Renderer.LumaUpscaler, Renderer.LumaDownscaler);
yield return(chromastatus.PrependToDescription("Chroma: "));
yield return(lumastatus.PrependToDescription("Luma: "));
}
// public int fibonacy_binary (int value , int max){
// if (value > max)
// return max;
// if (max / 2 < value)
// return max;
//
//
// return fibonacy_binary (value, max / 2);
//
//
// }
TextureSize GetTextureSize(TextureImporter textureImporter)
{
var method = typeof(TextureImporter).GetMethod("GetWidthAndHeight", BindingFlags.NonPublic | BindingFlags.Instance);
textureSizeDelegate = System.Delegate.CreateDelegate(typeof(GetTextureSize), method) as GetTextureSize;
TextureSize size = new TextureSize();
textureSizeDelegate.Invoke(textureImporter, ref size.width, ref size.height);
return(size);
}
public ITextureFilter SetSize(TextureSize targetSize)
{
var result = new ResizeFilter(InputFilter, targetSize, m_Channels, m_Offset, m_Upscaler, m_Downscaler, m_Convolver, Output.Format);
if (m_Tagged)
{
result.EnableTag();
}
return(result);
}
private void LoadSizeConstant(string identifier, TextureSize size)
{
if (size.Is3D)
{
SetConstant(string.Format("size3d{0}", identifier), new Vector4(size.Width, size.Height, size.Depth, 0));
}
else
{
SetConstant(string.Format("size{0}", identifier), new Vector4(size.Width, size.Height, 1.0f / size.Width, 1.0f / size.Height));
}
}
Vector3 GetRelativeTerrainPositionFromPosition(Vector3 position, TextureSize map)
{
Vector3 tmpCoord = (position - terrain.gameObject.transform.position);
Vector3 coord;
coord.x = tmpCoord.x / terrain.terrainData.size.x;
coord.y = tmpCoord.y / terrain.terrainData.size.y;
coord.z = tmpCoord.z / terrain.terrainData.size.z;
return new Vector3((coord.x * map.width), 0, (coord.z * map.height));
}
protected override ITextureFilter CreateFilter(ITextureFilter input)
{
if (Renderer.InputFormat.IsRgb())
{
return(input);
}
int bits = Renderer.InputFormat.GetBitDepth();
if (bits > MaxBitDepth)
{
return(input);
}
float[] consts =
{
(1 << bits) - 1,
Power
};
var Deband = new Shader(FromFile("Deband.hlsl", compilerOptions: PreserveDetail ? "PRESERVE_DETAIL=1" : ""))
{
Arguments = consts,
PerTextureLinearSampling = new[] { true, false }
};
ITextureFilter yuv = input.ConvertToYuv();
var inputsize = yuv.Size();
var deband = yuv;
double factor = 2.0;// 0.5 * Math.Sqrt(5) + 0.5;
int maxWidth = Math.Min(Math.Min(inputsize.Width, inputsize.Height) / 3, 256);
int max = (int)Math.Floor(Math.Log(maxWidth, factor));
for (int i = max; i >= 0; i--)
{
double scale = Math.Pow(factor, i);
var size = new TextureSize((int)Math.Round(inputsize.Width / scale), (int)Math.Round(inputsize.Height / scale));
if (size.Width == 0 || size.Height == 0)
{
continue;
}
if (i == 0)
{
size = inputsize;
}
Deband.Transform = s => size;
deband = Deband.ApplyTo(yuv, deband);
}
return(deband.ConvertToRgb());
}
public ResizeFilter(IFilter <ITextureOutput <ITexture2D> > inputFilter, TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler upscaler = null, IScaler downscaler = null, IScaler convolver = null, TextureFormat?outputFormat = null)
: base(outputSize, outputFormat ?? inputFilter.Output.Format, inputFilter)
{
m_OutputSize = outputSize;
m_Channels = channels;
m_Offset = offset;
m_Upscaler = upscaler ?? Renderer.LumaUpscaler;
m_Downscaler = downscaler ?? Renderer.LumaDownscaler;
m_Convolver = convolver;
}
public override IFilter CreateFilter(IFilter input)
{
if (Renderer.InputFormat.IsRgb())
{
return(input);
}
int bits = Renderer.InputFormat.GetBitDepth();
if (bits > maxbitdepth)
{
return(input);
}
float[] consts =
{
(1 << bits) - 1,
power
};
var Deband = CompileShader("Deband.hlsl", macroDefinitions: !grain ? "SkipDithering=1" : "")
.Configure(arguments: consts, perTextureLinearSampling: new[] { true, false });
/*var Subtract = CompileShader("Subtract.hlsl")
* .Configure(perTextureLinearSampling: new[] { false, true }, format: TextureFormat.Float16);
* var SubtractLimited = CompileShader("SubtractLimited.hlsl")
* .Configure(perTextureLinearSampling: new[] { false, true }, arguments: Consts);*/
IFilter yuv = input.ConvertToYuv();
var inputsize = yuv.OutputSize;
var deband = yuv;
double factor = 2.0;// 0.5 * Math.Sqrt(5) + 0.5;
int max = (int)Math.Floor(Math.Log(Math.Min(inputsize.Width, inputsize.Height) / 3.0, factor));
for (int i = max; i >= 0; i--)
{
double scale = Math.Pow(factor, i);
var size = new TextureSize((int)Math.Round(inputsize.Width / scale), (int)Math.Round(inputsize.Height / scale));
if (size.Width == 0 || size.Height == 0)
{
continue;
}
if (i == 0)
{
size = inputsize;
}
deband = new ShaderFilter(Deband.Configure(transform: s => size), yuv, deband);
}
return(deband.ConvertToRgb());
}
static int GetTextureSize(TextureSize type)
{
switch (type)
{
case TextureSize.MAX_1024: return(1024);
case TextureSize.MAX_2048: return(2048);
case TextureSize.MAX_4096: return(4096);
}
return(1024);
}
public Process(TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler upscaler = null, IScaler downscaler = null, IScaler convolver = null, TextureFormat?outputFormat = null)
{
m_OutputSize = outputSize;
m_Channels = channels;
m_Offset = offset;
m_Format = outputFormat;
m_Upscaler = upscaler ?? Renderer.LumaUpscaler;
m_Downscaler = downscaler ?? Renderer.LumaDownscaler;
m_Convolver = convolver;
}
void Start()
{
terrain=gameObject.GetComponent<Terrain>();
heightmapSize = new TextureSize(terrain.terrainData.heightmapWidth,terrain.terrainData.heightmapHeight);
alphamapSize = new TextureSize(terrain.terrainData.alphamapWidth,terrain.terrainData.alphamapHeight);
numberOfAlphaLayers = terrain.terrainData.alphamapLayers;
if (Debug.isDebugBuild){
heightmapBackup = terrain.terrainData.GetHeights(0, 0, heightmapSize.width, heightmapSize.height);
alphamapBackup = terrain.terrainData.GetAlphamaps(0, 0, alphamapSize.width, alphamapSize.height);
}
}
public VideoSourceFilter(TrueSourceFilter trueSource, TextureSize?outputSize = null, bool?wantYuv = null)
: base(trueSource)
{
m_TrueSource = trueSource;
m_OutputSize = outputSize ?? trueSource.OutputSize;
m_WantYuv = wantYuv ?? trueSource.WantYuv;
if (m_WantYuv)
{
m_TrueSource.WantYuv = true;
}
m_TrueSource.OutputSize = m_OutputSize;
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var textureSize = TextureSize.GetFirstValue(payload.Data);
var entropy = Entropy.GetFirstValue(payload.Data);
var entropySteps = (from step in EntropySteps.GetFirstValue(payload.Data).Split(',') select float.Parse(step.Trim())).ToArray();
var minimumEntropyLevels = MinimumEntropyLevels.GetFirstValue(payload.Data);
var colorOne = ColorOne.GetFirstValue(payload.Data);
var colorTwo = ColorTwo.GetFirstValue(payload.Data);
var entropyGridTexture = new Texture2D(textureSize, textureSize);
var entropyLevel = 0;
while (entropyLevel < entropySteps.Length && entropy > entropySteps[entropyLevel])
{
entropyLevel++;
}
entropyLevel += minimumEntropyLevels;
var pixels = new Color[textureSize * textureSize];
for (int x = 0; x < textureSize; x++)
{
for (int y = 0; y < textureSize; y++)
{
var xImpact = Mathf.FloorToInt((x / (float)textureSize) * entropyLevel);
var yImpact = Mathf.FloorToInt((y / (float)textureSize) * entropyLevel);
pixels[x + y * textureSize] = ((xImpact + yImpact) % 2) == 1 ? colorOne : colorTwo;
}
}
entropyGridTexture.SetPixels(pixels);
entropyGridTexture.Apply();
TextureTarget.SetValue(entropyGridTexture, payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public static string ScaleDescription(TextureSize inputSize, TextureSize outputSize, IScaler upscaler, IScaler downscaler, IScaler convolver = null)
{
var xDesc = ScaleDescription(inputSize.Width, outputSize.Width, upscaler, downscaler, convolver);
var yDesc = ScaleDescription(inputSize.Height, outputSize.Height, upscaler, downscaler, convolver);
if (xDesc == yDesc)
{
return(xDesc);
}
xDesc = xDesc.PrependToStatus("X:");
yDesc = yDesc.PrependToStatus("Y:");
return(xDesc.AppendStatus(yDesc));
}
/// <summary>
/// Builds resource description for a render target texture array
/// </summary>
/// <param name="size">Texture size</param>
/// <param name="format">Texture format</param>
/// <param name="arraySize">Texture array element count</param>
/// <returns>Texture2D Description</returns>
public static Texture2DDescription GetRenderTargetTextureArray(TextureSize size, Format format, int arraySize)
{
return(new Texture2DDescription()
{
ArraySize = arraySize,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = size.Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
Width = size.Width
});
}
/// <summary>
/// Gets an immutable texture description, data can be uploaded thread free
/// </summary>
/// <param name="size">Texture size</param>
/// <param name="format">Texture format</param>
/// <returns>Direct3D11 Texture description</returns>
public static Texture2DDescription GetImmutableTexture(TextureSize size, Format format)
{
return(new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = size.Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Immutable,
Width = size.Width
});
}
void OnPreprocessTexture()
{
if (!setting.enableTextureImporter)
{
return;
}
TextureImporter textureImporter = (TextureImporter)assetImporter;
textureImporter.sRGBTexture = true;
TextureSize size = GetTextureSize(textureImporter);
int max = size.width > size.height ? size.width : size.height;
max = max.round_max(setting.textureMaxSize, 0x02);
textureImporter.maxTextureSize = max;
textureImporter.textureCompression = TextureImporterCompression.Uncompressed;
}
//-----------------------------------------
private void GenerateTexture(TextureSize size, int num)
{
Color _color = new Color(0f, 0f, 0f, 1f);
Color[] _pix = new Color[0];
int y = 0;
int x = 0;
int h = texturesPool[size][num].height;
int w = texturesPool[size][num].width;
switch (size)
{
case TextureSize.s32:
_pix = _pix32;
break;
case TextureSize.s64:
_pix = _pix64;
break;
case TextureSize.s128:
_pix = _pix128;
break;
case TextureSize.s256:
_pix = _pix256;
break;
}
while (y < h)
{
x = 0;
while (x < w)
{
_color.r = Random.Range(0f, 1f);
_color.g = Random.Range(0f, 1f);
_color.b = Random.Range(0f, 1f);
_pix[y * w + x] = _color;
x++;
}
y++;
}
texturesPool[size][num].SetPixels(_pix);
texturesPool[size][num].Apply();
}
private TextureSize CalculateSize(TextureSize sizeA, TextureSize sizeB, int k)
{
double w, h;
var MaxScale = 2.0;
var MinScale = Math.Sqrt(MaxScale);
int minW = sizeA.Width; int minH = sizeA.Height;
int maxW = sizeB.Width; int maxH = sizeB.Height;
int maxSteps = (int)Math.Floor(Math.Log((double)(maxH * maxW) / (double)(minH * minW)) / (2 * Math.Log(MinScale)));
int minSteps = (int)Math.Ceiling(Math.Log((double)(maxH * maxW) / (double)(minH * minW)) / (2 * Math.Log(MaxScale)));
int steps = Math.Max(Math.Max(1, minSteps), Math.Min(maxSteps, Passes - (k - 1)));
w = minW * Math.Pow((double)maxW / (double)minW, (double)Math.Min(k, steps) / (double)steps);
h = minW * Math.Pow((double)maxH / (double)minH, (double)Math.Min(k, steps) / (double)steps);
return(new TextureSize(Math.Max(minW, Math.Min(maxW, (int)Math.Round(w))),
Math.Max(minH, Math.Min(maxH, (int)Math.Round(h)))));
}
void TextureDeform(Vector3 position, float craterSizeInMeters)
{
Vector3 alphamapTerrainPosition = GetRelativeTerrainPositionFromPosition(position, alphamapSize);
TextureSize alphamapCrater = new TextureSize(
(int) (craterSizeInMeters * (alphamapSize.width / terrain.terrainData.size.x)),
(int) (craterSizeInMeters * (alphamapSize.height / terrain.terrainData.size.z)));
int alphamapStartPosX = (int)(alphamapTerrainPosition.x - (alphamapCrater.width / 2));
int alphamapStartPosZ = (int)(alphamapTerrainPosition.z - (alphamapCrater.height/2));
float[, ,] alphas = terrain.terrainData.GetAlphamaps(alphamapStartPosX, alphamapStartPosZ, alphamapCrater.width, alphamapCrater.height);
float circlePosX;
float circlePosY;
float distanceFromCenter;
for (int i=0;i<alphamapCrater.height;i++){
for(int j=0;j<alphamapCrater.width;j++){
circlePosX = (j - (alphamapCrater.width / 2)) / (alphamapSize.width / terrain.terrainData.size.x);
circlePosY = (i - (alphamapCrater.height / 2)) / (alphamapSize.height / terrain.terrainData.size.z);
distanceFromCenter = Mathf.Abs(Mathf.Sqrt(circlePosX * circlePosX + circlePosY * circlePosY));
if (distanceFromCenter < (craterSizeInMeters / 2.0f)){
for (int layerCounter=0;layerCounter<numberOfAlphaLayers;layerCounter++){
//if(layerCounter==deformationTextureIDs[0]){
//if(layerCounter==deformationTextureIDs[Random.Range(0, deformationTextureIDs.Length)]){
if(layerCounter==explosionTexIdx){
alphas[i,j,layerCounter]=1;
}
else{
alphas[i,j,layerCounter]=0;
}
}
}
}
}
terrain.terrainData.SetAlphamaps(alphamapStartPosX, alphamapStartPosZ, alphas);
}
