private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
time *= 0.25f;
float num = time % 1f;
bool num2 = time % 2f > 1f;
Vector4 vector = num2 ? _secondaryColor : _primaryColor;
Vector4 value = num2 ? _primaryColor : _secondaryColor;
num *= 1.2f;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.5f + new Vector2(0f, time * 0.5f));
Vector4 value2 = vector;
staticNoise += num;
if (staticNoise > 0.999f)
{
float amount = MathHelper.Clamp((staticNoise - 0.999f) / 0.2f, 0f, 1f);
value2 = Vector4.Lerp(value2, value, amount);
}
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 100f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 20f);
value2 = Vector4.Lerp(value2, _gemColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % _gemColors.Length + _gemColors.Length) % _gemColors.Length], dynamicNoise);
fragment.SetColor(i, value2);
fragment.SetColor(i, value2);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Invalid comparison between Unknown and I4
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
if ((int)device.Type != 0 && (int)device.Type != 6)
{
ProcessLowDetail(device, fragment, quality, time);
return;
}
Vector2 value = new Vector2(2f, 0.5f);
Vector2 value2 = new Vector2(2.5f, 1f);
float num = _progress * (float)Math.PI + (float)Math.PI;
Vector2 value3 = new Vector2((float)Math.Cos(num), (float)Math.Sin(num)) * value2 + value;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * new Vector2(0.1f, 0.5f) + new Vector2(time * 0.02f, 0f), time / 40f);
dynamicNoise = (float)Math.Sqrt(Math.Max(0f, 1f - 2f * dynamicNoise));
float num2 = (canvasPositionOfIndex - value3).Length();
Vector4 vector = Vector4.Lerp(_skyColor, _cloudColor, dynamicNoise * 0.15f);
if (num2 < 0.8f)
{
vector = Vector4.Lerp(_moonRingColor, _moonCoreColor, Math.Min(0.1f, 0.8f - num2) / 0.1f);
}
else if (num2 < 1f)
{
vector = Vector4.Lerp(vector, _moonRingColor, Math.Min(0.2f, 1f - num2) / 0.2f);
}
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
time *= 0.25f;
float num1 = time % 1f;
int num2 = (double)time % 2.0 > 1.0 ? 1 : 0;
Vector4 vector4_1 = num2 != 0 ? this._secondaryColor : this._primaryColor;
Vector4 vector4_2 = num2 != 0 ? this._primaryColor : this._secondaryColor;
float num3 = num1 * 1.2f;
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.5f + new Vector2(0.0f, time * 0.5f));
Vector4 vector4_3 = vector4_1;
float num4 = staticNoise + num3;
if ((double)num4 > 0.999000012874603)
{
float amount = MathHelper.Clamp((float)(((double)num4 - 0.999000012874603) / 0.200000002980232), 0.0f, 1f);
vector4_3 = Vector4.Lerp(vector4_3, vector4_2, amount);
}
float amount1 = Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 100f) * 20.0));
Vector4 vector4_4 = Vector4.Lerp(vector4_3, GemCaveShader._gemColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % GemCaveShader._gemColors.Length + GemCaveShader._gemColors.Length) % GemCaveShader._gemColors.Length], amount1);
fragment.SetColor(index, vector4_4);
fragment.SetColor(index, vector4_4);
}
}
private void ProcessLowDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(fragment.GetCanvasPositionOfIndex(i) * 0.3f, time / 5f);
Vector4 vector = Vector4.Lerp(_backgroundColor, _sporeColor, dynamicNoise);
fragment.SetColor(i, vector);
}
}
private void ProcessLowDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(fragment.GetCanvasPositionOfIndex(i) * new Vector2(0.1f, 0.5f) + new Vector2(time * 0.02f, 0f), time / 40f);
dynamicNoise = (float)Math.Sqrt(Math.Max(0f, 1f - 2f * dynamicNoise));
Vector4 vector = Vector4.Lerp(_skyColor, _cloudColor, dynamicNoise * 0.1f);
fragment.SetColor(i, vector);
}
}
private void ProcessLowDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(fragment.GetCanvasPositionOfIndex(i), time * 0.25f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 2f);
Vector4 vector = Vector4.Lerp(_slimeColor, _debrisColor, dynamicNoise);
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(fragment.GetGridPositionOfIndex(i).Y, time);
float val = (float)Math.Sin(canvasPositionOfIndex.X + 2f * time + dynamicNoise) - 0.2f;
val = Math.Max(0f, val);
Vector4 vector = Vector4.Lerp(_primaryColor, _secondaryColor, val);
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 secondaryColor = _secondaryColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.3f, time / 5f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 2f);
secondaryColor = Vector4.Lerp(secondaryColor, _primaryColor, (float)Math.Sqrt(dynamicNoise) * 0.75f);
fragment.SetColor(i, secondaryColor);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector4 vector4 = Vector4.Lerp(this._backColor, this._frontColor, NoiseHelper.GetDynamicNoise(fragment.GetCanvasPositionOfIndex(index) * 0.5f, (float)((double)time * (double)this._speed / 3.0)));
fragment.SetColor(index, vector4);
}
}
private void ProcessLowDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector4 value = Vector4.Lerp(_veinColor, _eyeColor, (float)Math.Sin(time + canvasPositionOfIndex.X * 4f) * 0.5f + 0.5f);
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 25f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 5f);
value = Vector4.Lerp(value, _irisColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % _irisColors.Length + _irisColors.Length) % _irisColors.Length], dynamicNoise);
fragment.SetColor(i, value);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
float dynamicNoise = NoiseHelper.GetDynamicNoise(fragment.GetGridPositionOfIndex(index).Y, time);
Vector4 vector4 = Vector4.Lerp(this._primaryColor, this._secondaryColor, Math.Max(0.0f, (float)Math.Sin((double)canvasPositionOfIndex.X + 2.0 * (double)time + (double)dynamicNoise) - 0.2f));
fragment.SetColor(index, vector4);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.3f + new Vector2(12.5f, time * 0.05f), time * 0.1f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * dynamicNoise * 4f * (1.2f - canvasPositionOfIndex.Y)) * canvasPositionOfIndex.Y;
dynamicNoise = MathHelper.Clamp(dynamicNoise, 0f, 1f);
Vector4 value = Vector4.Lerp(_flameColor, _flameTipColor, dynamicNoise);
Vector4 vector = Vector4.Lerp(_corruptionColor, value, dynamicNoise);
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(new Vector2((canvasPositionOfIndex.X - canvasPositionOfIndex.Y) * 0.2f, 0f), time / 5f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 1.5f);
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(new Vector2((canvasPositionOfIndex.X - canvasPositionOfIndex.Y) * 0.3f, 0.3f), time / 20f);
dynamicNoise2 = Math.Max(0f, 1f - dynamicNoise2 * 5f);
Vector4 value = Vector4.Lerp(_baseColor, _iceColor, dynamicNoise);
value = Vector4.Lerp(value, _shineColor, dynamicNoise2);
fragment.SetColor(i, value);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 baseColor = _baseColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.4f, time * 0.05f);
dynamicNoise = Math.Max(0f, 1f - 2.5f * dynamicNoise);
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.4f + new Vector2(0.05f, 0f), time * 0.05f);
dynamicNoise2 = Math.Max(0f, 1f - 2.5f * dynamicNoise2);
baseColor = ((!(dynamicNoise > dynamicNoise2)) ? Vector4.Lerp(baseColor, _blueCrystalColor, dynamicNoise2) : Vector4.Lerp(baseColor, _pinkCrystalColor, dynamicNoise));
fragment.SetColor(i, baseColor);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector4 baseColor = _baseColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 10f);
baseColor = Vector4.Lerp(baseColor, _secondaryColor, dynamicNoise * dynamicNoise);
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.5f + new Vector2(0f, time * 0.05f), time / 20f);
dynamicNoise2 = Math.Max(0f, 1f - dynamicNoise2 * 2f);
baseColor = Vector4.Lerp(baseColor, _glowColor, (float)Math.Sqrt(dynamicNoise2) * 0.75f);
fragment.SetColor(i, baseColor);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
new Vector2(1.6f, 0.5f);
Vector4 value = Vector4.Lerp(_brainColor, _veinColor, Math.Max(0f, (float)Math.Sin(time * 3f)) * 0.5f + 0.5f);
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 brainColor = _brainColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.15f + new Vector2(time * 0.002f), time * 0.03f);
dynamicNoise = (float)Math.Sin(dynamicNoise * 10f) * 0.5f + 0.5f;
dynamicNoise = Math.Max(0f, 1f - 5f * dynamicNoise);
brainColor = Vector4.Lerp(brainColor, value, dynamicNoise);
fragment.SetColor(i, brainColor);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector4 baseColor = this._baseColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 10f);
Vector4 vector4 = Vector4.Lerp(Vector4.Lerp(baseColor, this._secondaryColor, dynamicNoise * dynamicNoise), this._glowColor, (float)Math.Sqrt((double)Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.5f + new Vector2(0.0f, time * 0.05f), time / 20f) * 2.0))) * 0.75f);
fragment.SetColor(index, vector4);
}
}
private void ProcessLowDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector4 vector4_1 = Vector4.Lerp(this._veinColor, this._eyeColor, (float)(Math.Sin((double)time + (double)canvasPositionOfIndex.X * 4.0) * 0.5 + 0.5));
float amount = Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 25f) * 5.0));
Vector4 vector4_2 = Vector4.Lerp(vector4_1, TwinsShader._irisColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % TwinsShader._irisColors.Length + TwinsShader._irisColors.Length) % TwinsShader._irisColors.Length], amount);
fragment.SetColor(index, vector4_2);
}
}
private void ProcessAnyDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * new Vector2(0.1f, 0.5f) + new Vector2(time * 0.05f, 0f), time / 20f);
dynamicNoise = (float)Math.Sqrt(Math.Max(0f, 1f - 2f * dynamicNoise));
Vector4 value = Vector4.Lerp(_processedSkyColor, _processedCloudColor, dynamicNoise);
value = Vector4.Lerp(_baseSpaceColor, value, _backgroundTransition);
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 60f);
dynamicNoise2 = Math.Max(0f, 1f - dynamicNoise2 * 20f);
value = Vector4.Lerp(value, Vector4.One, dynamicNoise2 * 0.98f * _starVisibility);
fragment.SetColor(i, value);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
fragment.GetGridPositionOfIndex(index);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.3f + new Vector2(12.5f, time * 0.05f), time * 0.1f);
float amount = MathHelper.Clamp(Math.Max(0.0f, (float)(1.0 - (double)dynamicNoise * (double)dynamicNoise * 4.0 * (1.20000004768372 - (double)canvasPositionOfIndex.Y))) * canvasPositionOfIndex.Y, 0.0f, 1f);
Vector4 vector4 = Vector4.Lerp(this._corruptionColor, Vector4.Lerp(this._flameColor, this._flameTipColor, amount), amount);
fragment.SetColor(index, vector4);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
fragment.GetGridPositionOfIndex(index);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Vector4 baseColor = this._baseColor;
float amount1 = Math.Max(0.0f, (float)(1.0 - 2.5 * (double)NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.4f, time * 0.05f)));
float amount2 = Math.Max(0.0f, (float)(1.0 - 2.5 * (double)NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.4f + new Vector2(0.05f, 0.0f), time * 0.05f)));
Vector4 vector4 = (double)amount1 <= (double)amount2 ? Vector4.Lerp(baseColor, this._blueCrystalColor, amount2) : Vector4.Lerp(baseColor, this._pinkCrystalColor, amount1);
fragment.SetColor(index, vector4);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
Vector4 value = _primaryColor * _surfaceColor;
Vector4 value2 = _secondaryColor * _surfaceColor;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
float amount = (float)Math.Sin(canvasPositionOfIndex.X * 1.5f + canvasPositionOfIndex.Y + time) * 0.5f + 0.5f;
Vector4 value3 = Vector4.Lerp(value, value2, amount);
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 60f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 20f);
dynamicNoise *= 1f - _surfaceColor.X;
value3 = Vector4.Max(value3, new Vector4(dynamicNoise * _starVisibility));
fragment.SetColor(i, value3);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
Vector4 vector = _skyColor * _lightColor;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 20f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 5f);
Vector4 value = vector;
value = (((gridPositionOfIndex.X * 100 + gridPositionOfIndex.Y) % 2 != 0) ? Vector4.Lerp(value, _pinkFlowerColor, dynamicNoise) : Vector4.Lerp(value, _yellowFlowerColor, dynamicNoise));
float num = (float)Math.Sin(canvasPositionOfIndex.X) * 0.3f + 0.7f;
if (canvasPositionOfIndex.Y > num)
{
value = _groundColor;
}
fragment.SetColor(i, value);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
bool flag = device.Type == null || device.Type == 6;
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector4 vector4 = Vector4.Lerp(this._backgroundColor, this._sporeColor, Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.3f, time / 5f) * 2.5)));
if (flag)
{
float amount = Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 100f) * 20.0));
vector4 = Vector4.Lerp(vector4, this._flowerColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % 5 + 5) % 5], amount);
}
fragment.SetColor(index, vector4);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 vector = _backgroundColor;
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.2f, time * 0.5f);
float num = 0.4f;
num += dynamicNoise * 0.4f;
float num2 = 1.1f - canvasPositionOfIndex.Y;
if (num2 < num)
{
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.3f + new Vector2(12.5f, time * 0.2f));
staticNoise = Math.Max(0f, 1f - staticNoise * staticNoise * 4f * staticNoise);
staticNoise = MathHelper.Clamp(staticNoise, 0f, 1f);
Vector4 value = Vector4.Lerp(_primaryColor, _secondaryColor, staticNoise);
float amount = 1f - MathHelper.Clamp((num2 - num + 0.2f) / 0.2f, 0f, 1f);
vector = Vector4.Lerp(vector, value, amount);
}
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
Vector4 vector4_1 = this._skyColor * this._lightColor;
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
float amount = Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 20f) * 5.0));
Vector4 vector4_2 = vector4_1;
Vector4 vector4_3 = (gridPositionOfIndex.X * 100 + gridPositionOfIndex.Y) % 2 != 0 ? Vector4.Lerp(vector4_2, this._pinkFlowerColor, amount) : Vector4.Lerp(vector4_2, this._yellowFlowerColor, amount);
if ((double)canvasPositionOfIndex.Y > Math.Sin((double)canvasPositionOfIndex.X) * 0.300000011920929 + 0.699999988079071)
{
vector4_3 = this._groundColor;
}
fragment.SetColor(index, vector4_3);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Vector4 vector4_1 = this._backgroundColor;
float num1 = 0.4f + NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.2f, time * 0.5f) * 0.4f;
float num2 = 1.1f - canvasPositionOfIndex.Y;
if ((double)num2 < (double)num1)
{
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.3f + new Vector2(12.5f, time * 0.2f));
Vector4 vector4_2 = Vector4.Lerp(this._primaryColor, this._secondaryColor, MathHelper.Clamp(Math.Max(0.0f, (float)(1.0 - (double)staticNoise * (double)staticNoise * 4.0 * (double)staticNoise)), 0.0f, 1f));
float amount = 1f - MathHelper.Clamp((float)(((double)num2 - (double)num1 + 0.200000002980232) / 0.200000002980232), 0.0f, 1f);
vector4_1 = Vector4.Lerp(vector4_1, vector4_2, amount);
}
fragment.SetColor(index, vector4_1);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Invalid comparison between Unknown and I4
bool flag = (int)device.Type == 0 || (int)device.Type == 6;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.3f, time / 5f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 2.5f);
Vector4 vector = Vector4.Lerp(_backgroundColor, _sporeColor, dynamicNoise);
if (flag)
{
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(gridPositionOfIndex.X, gridPositionOfIndex.Y, time / 100f);
dynamicNoise2 = Math.Max(0f, 1f - dynamicNoise2 * 20f);
vector = Vector4.Lerp(vector, _flowerColors[((gridPositionOfIndex.Y * 47 + gridPositionOfIndex.X) % 5 + 5) % 5], dynamicNoise2);
}
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
time *= 2f;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 backgroundColor = _backgroundColor;
float num = time * 0.5f + canvasPositionOfIndex.X + canvasPositionOfIndex.Y;
float value = (float)Math.Cos(num) * 2f + 2f;
value = MathHelper.Clamp(value, 0f, 1f);
num = (num + (float)Math.PI) % ((float)Math.PI * 6f);
Vector4 value2;
if (num < (float)Math.PI * 2f)
{
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.3f + new Vector2(12.5f, time * 0.2f));
staticNoise = Math.Max(0f, 1f - staticNoise * staticNoise * 4f * staticNoise);
staticNoise = MathHelper.Clamp(staticNoise, 0f, 1f);
value2 = Vector4.Lerp(_fireDarkColor, _fireBrightColor, staticNoise);
}
else if (num < (float)Math.PI * 4f)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(new Vector2((canvasPositionOfIndex.X + canvasPositionOfIndex.Y) * 0.2f, 0f), time / 5f);
dynamicNoise = Math.Max(0f, 1f - dynamicNoise * 1.5f);
value2 = Vector4.Lerp(_iceDarkColor, _iceBrightColor, dynamicNoise);
}
else
{
float dynamicNoise2 = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex * 0.15f, time * 0.05f);
dynamicNoise2 = (float)Math.Sin(dynamicNoise2 * 15f) * 0.5f + 0.5f;
dynamicNoise2 = Math.Max(0f, 1f - 5f * dynamicNoise2);
value2 = Vector4.Lerp(_lightningDarkColor, _lightningBrightColor, dynamicNoise2);
}
backgroundColor = Vector4.Lerp(backgroundColor, value2, value);
fragment.SetColor(i, backgroundColor);
}
}
private void ProcessLowDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector4 vector4 = Vector4.Lerp(this._slimeColor, this._debrisColor, Math.Max(0.0f, (float)(1.0 - (double)NoiseHelper.GetDynamicNoise(fragment.GetCanvasPositionOfIndex(index), time * 0.25f) * 2.0)));
fragment.SetColor(index, vector4);
}
}
