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 i = 0; i < fragment.Count; i++)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float num = ((NoiseHelper.GetStaticNoise(gridPositionOfIndex.Y) * 10f + time) % 10f - (canvasPositionOfIndex.X + 2f)) * 0.5f;
Vector4 vector = _backgroundColor;
if (num > 0f)
{
float num2 = Math.Max(0f, 1.2f - num);
float amount = MathHelper.Clamp(num2 * num2 * num2, 0f, 1f);
if (num < 0.2f)
{
num2 = num / 0.2f;
}
Vector4 value = Vector4.Lerp(_spiritTrailColor, _spiritColor, amount);
vector = Vector4.Lerp(vector, value, num2);
}
fragment.SetColor(i, vector);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
time *= _speed * 0.5f;
float num = time % 1f;
bool num2 = time % 2f > 1f;
Vector4 vector = (num2 ? _frontColor : _backColor);
Vector4 value = (num2 ? _backColor : _frontColor);
num *= 1.2f;
for (int i = 0; i < fragment.Count; i++)
{
float staticNoise = NoiseHelper.GetStaticNoise(fragment.GetCanvasPositionOfIndex(i) * 0.5f + new Vector2(0f, time * 0.5f));
Vector4 vector2 = vector;
staticNoise += num;
if (staticNoise > 0.999f)
{
float amount = MathHelper.Clamp((staticNoise - 0.999f) / 0.2f, 0f, 1f);
vector2 = Vector4.Lerp(vector2, value, amount);
}
fragment.SetColor(i, vector2);
}
}
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)
{
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)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
float num1 = (float)(((double)NoiseHelper.GetStaticNoise(gridPositionOfIndex.X) * 10.0 + (double)time * 0.400000005960464) % 10.0);
float num2 = 1f;
if ((double)num1 > 1.0)
{
num2 = MathHelper.Clamp((float)(1.0 - ((double)num1 - 1.39999997615814)), 0.0f, 1f);
num1 = 1f;
}
float num3 = (float)(Math.Sin((double)canvasPositionOfIndex.X) * 0.300000011920929 + 0.699999988079071);
float num4 = num1 - (1f - canvasPositionOfIndex.Y);
Vector4 vector4_2 = vector4_1;
if ((double)num4 > 0.0)
{
float num5 = 1f;
if ((double)num4 < 0.200000002980232)
{
num5 = num4 * 5f;
}
vector4_2 = Vector4.Lerp(vector4_2, this._baseColor, num5 * num2);
}
if ((double)canvasPositionOfIndex.Y > (double)num3)
{
vector4_2 = this._baseColor;
}
fragment.SetColor(index, vector4_2);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
// get_CanvasCenter() to CanvasCenter, maybe (\.get_)(.*?)(\(\)) to .$2
Vector2 vector2_1 = fragment.CanvasCenter;
if (quality == null)
{
vector2_1 = new Vector2(1.7f, 0.5f);
}
time *= 0.5f;
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Vector4 vector4_1 = new Vector4(0.0f, 0.0f, 0.0f, 1f);
Vector2 vector2_2 = vector2_1;
float num1 = (canvasPositionOfIndex - vector2_2).Length();
float num2 = (float)((double)num1 * (double)num1 * 0.75);
float num3 = (float)(((double)num1 - (double)time) % 1.0);
if ((double)num3 < 0.0)
{
++num3;
}
float num4 = (double)num3 <= 0.800000011920929 ? num3 / 0.8f : num3 * (float)(1.0 - ((double)num3 - 1.0 + 0.200000002980232) / 0.200000002980232);
Vector4 vector4_2 = Vector4.Lerp(this._darkGlowColor, this._lightGlowColor, num4 * num4);
float amount1 = num4 * (float)((double)MathHelper.Clamp(1f - num2, 0.0f, 1f) * 0.75 + 0.25);
vector4_1 = Vector4.Lerp(vector4_1, vector4_2, amount1);
if ((double)num1 < 0.5)
{
float amount2 = 1f - MathHelper.Clamp((float)(((double)num1 - 0.5 + 0.400000005960464) / 0.400000005960464), 0.0f, 1f);
vector4_1 = Vector4.Lerp(vector4_1, this._lightGlowColor, amount2);
}
fragment.SetColor(index, vector4_1);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
Vector4 value = (_inBloodMoon ? new Vector4(1f, 0f, 0f, 1f) : new Vector4(0f, 0f, 1f, 1f));
Vector4 vector = new Vector4(0f, 0f, 0f, 0.75f);
for (int i = 0; i < fragment.Count; i++)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float num = (NoiseHelper.GetStaticNoise(gridPositionOfIndex.X) * 10f + time) % 10f - canvasPositionOfIndex.Y;
Vector4 vector2 = vector;
if (num > 0f)
{
float amount = Math.Max(0f, 1.2f - num);
if (num < 0.2f)
{
amount = num * 5f;
}
vector2 = Vector4.Lerp(vector2, value, amount);
}
fragment.SetColor(i, vector2);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
Vector4 vector = new Vector4(0f, 0f, 0f, 0.75f);
for (int i = 0; i < fragment.Count; i++)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
float num = (NoiseHelper.GetStaticNoise(gridPositionOfIndex.X) * 7f + time * 0.4f) % 7f - canvasPositionOfIndex.Y;
Vector4 vector2 = vector;
if (num > 0f)
{
float amount = Math.Max(0f, 1.2f - num);
if (num < 0.4f)
{
amount = num / 0.4f;
}
int num2 = (gridPositionOfIndex.X % _colors.Length + _colors.Length) % _colors.Length;
vector2 = Vector4.Lerp(vector2, _colors[num2], amount);
}
fragment.SetColor(i, vector2);
}
}
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)
{
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
float staticNoise = NoiseHelper.GetStaticNoise(fragment.GetGridPositionOfIndex(index).X / 2);
float num = (float)(((double)canvasPositionOfIndex.Y + (double)canvasPositionOfIndex.X / 2.0 - (double)staticNoise + (double)time) % 2.0);
if ((double)num < 0.0)
{
num += 2f;
}
if ((double)num < 0.200000002980232)
{
num = (float)(1.0 - (double)num / 0.200000002980232);
}
Vector4 vector4 = Vector4.Lerp(this._primaryColor, this._secondaryColor, num / 2f);
fragment.SetColor(index, vector4);
}
}
private void ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
Vector2 value = new Vector2(1.5f, 0.5f);
time *= 4f;
for (int i = 0; i < fragment.Count; i++)
{
Vector2 vector = fragment.GetCanvasPositionOfIndex(i) - value;
float num = vector.Length() * 2f;
float num2 = (float)Math.Atan2(vector.Y, vector.X);
float amount = (float)Math.Sin(num * 4f - time - num2) * 0.5f + 0.5f;
Vector4 vector2 = Vector4.Lerp(_primaryColor, _secondaryColor, amount);
if (num < 1f)
{
float num3 = num / 1f;
num3 *= num3 * num3;
float amount2 = (float)Math.Sin(4f - time - num2) * 0.5f + 0.5f;
vector2 = Vector4.Lerp(_primaryColor, _secondaryColor, amount2) * num3;
}
vector2.W = 1f;
fragment.SetColor(i, vector2);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
canvasPositionOfIndex.X -= 1.8f;
if ((double)canvasPositionOfIndex.X < 0.0)
{
canvasPositionOfIndex.X *= -1f;
gridPositionOfIndex.Y += 101;
}
float num1 = (float)(((double)NoiseHelper.GetStaticNoise(gridPositionOfIndex.Y) * 5.0 + (double)time * 0.400000005960464) % 5.0);
float num2 = 1f;
if ((double)num1 > 1.0)
{
num2 = 1f - MathHelper.Clamp((float)(((double)num1 - 0.400000005960464 - 1.0) / 0.400000005960464), 0.0f, 1f);
num1 = 1f;
}
float num3 = num1 - canvasPositionOfIndex.X / 5f;
Vector4 vector4 = this._backgroundColor;
if ((double)num3 > 0.0)
{
float num4 = 1f;
if ((double)num3 < 0.200000002980232)
{
num4 = num3 / 0.2f;
}
vector4 = (gridPositionOfIndex.X + 7 * gridPositionOfIndex.Y) % 5 != 0 ? Vector4.Lerp(this._backgroundColor, this._vineColor, num4 * num2) : Vector4.Lerp(this._backgroundColor, this._bulbColor, num4 * num2);
}
fragment.SetColor(index, vector4);
}
}
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 vector4 = this._backgroundColor;
float num = (float)(((double)NoiseHelper.GetStaticNoise(gridPositionOfIndex.Y * 7) * 10.0 + (double)time) % 10.0 - ((double)canvasPositionOfIndex.X + 2.0));
if ((double)num > 0.0)
{
float amount = Math.Max(0.0f, 1.2f - num);
if ((double)num < 0.200000002980232)
{
amount = num * 5f;
}
vector4 = Vector4.Lerp(vector4, this._glowColor, amount);
}
fragment.SetColor(index, vector4);
}
}
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 ProcessHighDetail(RgbDevice device, Fragment fragment, EffectDetailLevel quality, float time)
{
for (int i = 0; i < fragment.Count; i++)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Vector4 value = _baseColor;
float num = ((NoiseHelper.GetStaticNoise(gridPositionOfIndex.X) * 10f + time * 0.2f) % 10f - (1f - canvasPositionOfIndex.Y)) * 2f;
if (num > 0f)
{
float amount = Math.Max(0f, 1.5f - num);
if (num < 0.5f)
{
amount = num * 2f;
}
value = Vector4.Lerp(value, _sporeColor, amount);
}
float staticNoise = NoiseHelper.GetStaticNoise(canvasPositionOfIndex * 0.3f + new Vector2(0f, time * 0.1f));
staticNoise = Math.Max(0f, 1f - staticNoise * (1f + (1f - canvasPositionOfIndex.Y) * 4f));
staticNoise *= Math.Max(0f, (canvasPositionOfIndex.Y - 0.3f) / 0.7f);
value = Vector4.Lerp(value, _edgeGlowColor, staticNoise);
fragment.SetColor(i, value);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
for (int index = 0; index < fragment.Count; ++index)
{
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
gridPositionOfIndex.X /= 2;
double num1 = ((double)NoiseHelper.GetStaticNoise(gridPositionOfIndex.X) * 40.0 + (double)time * 1.0) % 40.0;
float amount1 = 0.0f;
float num2 = (float)(num1 - (double)canvasPositionOfIndex.Y / 1.20000004768372);
if (num1 > 1.0)
{
float num3 = (float)(1.0 - (double)canvasPositionOfIndex.Y / 1.20000004768372);
amount1 = (float)((1.0 - (double)Math.Min(1f, num2 - num3)) * (1.0 - (double)Math.Min(1f, num3 / 1f)));
}
Vector4 vector4 = this._backgroundColor;
if ((double)num2 > 0.0)
{
float amount2 = Math.Max(0.0f, (float)(1.20000004768372 - (double)num2 * 4.0));
if ((double)num2 < 0.100000001490116)
{
amount2 = num2 / 0.1f;
}
vector4 = Vector4.Lerp(Vector4.Lerp(vector4, this._cannonBallColor, amount2), this._splashColor, amount1);
}
if ((double)canvasPositionOfIndex.Y > 0.800000011920929)
{
vector4 = this._waterColor;
}
fragment.SetColor(index, vector4);
}
}
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;
}
bool flag = true;
float num = time * 0.1f % 2f;
if (num > 1f)
{
num = 2f - num;
flag = false;
}
Vector2 vector = new Vector2(num * 7f - 3.5f, 0f) + fragment.get_CanvasCenter();
for (int i = 0; i < fragment.Count; i++)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(i);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(i);
Vector4 vector2 = _backgroundColor;
Vector2 vector3 = canvasPositionOfIndex - vector;
float num2 = vector3.Length();
if (num2 < 0.5f)
{
float amount = 1f - MathHelper.Clamp((num2 - 0.5f + 0.2f) / 0.2f, 0f, 1f);
float num3 = MathHelper.Clamp((vector3.X + 0.5f - 0.2f) / 0.6f, 0f, 1f);
if (flag)
{
num3 = 1f - num3;
}
Vector4 value = Vector4.Lerp(_eyeColor, _veinColor, num3);
float value2 = (float)Math.Atan2(vector3.Y, vector3.X);
if (!flag && (float)Math.PI - Math.Abs(value2) < 0.6f)
{
value = _mouthColor;
}
vector2 = Vector4.Lerp(vector2, value, amount);
}
if (flag && gridPositionOfIndex.Y == 3 && canvasPositionOfIndex.X > vector.X)
{
float value3 = 1f - Math.Abs(canvasPositionOfIndex.X - vector.X * 2f - 0.5f) / 0.5f;
vector2 = Vector4.Lerp(vector2, _laserColor, MathHelper.Clamp(value3, 0f, 1f));
}
else if (!flag)
{
Vector2 vector4 = canvasPositionOfIndex - (vector - new Vector2(1.2f, 0f));
vector4.Y *= 3.5f;
float num4 = vector4.Length();
if (num4 < 0.7f)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex, time);
dynamicNoise = dynamicNoise * dynamicNoise * dynamicNoise;
dynamicNoise *= 1f - MathHelper.Clamp((num4 - 0.7f + 0.3f) / 0.3f, 0f, 1f);
vector2 = Vector4.Lerp(vector2, _flameColor, dynamicNoise);
}
}
fragment.SetColor(i, vector2);
}
}
private void ProcessHighDetail(
RgbDevice device,
Fragment fragment,
EffectDetailLevel quality,
float time)
{
if (device.Type != null && (int)device.Type != 6)
{
this.ProcessLowDetail(device, fragment, quality, time);
}
else
{
bool flag = true;
float num1 = (float)((double)time * 0.100000001490116 % 2.0);
if ((double)num1 > 1.0)
{
num1 = 2f - num1;
flag = false;
}
Vector2 vector2_1 = new Vector2((float)((double)num1 * 7.0 - 3.5), 0.0f) + fragment.CanvasCenter;
for (int index = 0; index < fragment.Count; ++index)
{
Vector2 canvasPositionOfIndex = fragment.GetCanvasPositionOfIndex(index);
Point gridPositionOfIndex = fragment.GetGridPositionOfIndex(index);
Vector4 vector4_1 = this._backgroundColor;
Vector2 vector2_2 = canvasPositionOfIndex - vector2_1;
float num2 = vector2_2.Length();
if ((double)num2 < 0.5)
{
float amount1 = 1f - MathHelper.Clamp((float)(((double)num2 - 0.5 + 0.200000002980232) / 0.200000002980232), 0.0f, 1f);
float amount2 = MathHelper.Clamp((float)(((double)vector2_2.X + 0.5 - 0.200000002980232) / 0.600000023841858), 0.0f, 1f);
if (flag)
{
amount2 = 1f - amount2;
}
Vector4 vector4_2 = Vector4.Lerp(this._eyeColor, this._veinColor, amount2);
float num3 = (float)Math.Atan2((double)vector2_2.Y, (double)vector2_2.X);
if (!flag && 3.14159274101257 - (double)Math.Abs(num3) < 0.600000023841858)
{
vector4_2 = this._mouthColor;
}
vector4_1 = Vector4.Lerp(vector4_1, vector4_2, amount1);
}
if (flag && gridPositionOfIndex.Y == 3 && (double)canvasPositionOfIndex.X > (double)vector2_1.X)
{
float num3 = (float)(1.0 - (double)Math.Abs((float)((double)canvasPositionOfIndex.X - (double)vector2_1.X * 2.0 - 0.5)) / 0.5);
vector4_1 = Vector4.Lerp(vector4_1, this._laserColor, MathHelper.Clamp(num3, 0.0f, 1f));
}
else if (!flag)
{
Vector2 vector2_3 = canvasPositionOfIndex - (vector2_1 - new Vector2(1.2f, 0.0f));
vector2_3.Y *= 3.5f;
float num3 = vector2_3.Length();
if ((double)num3 < 0.699999988079071)
{
float dynamicNoise = NoiseHelper.GetDynamicNoise(canvasPositionOfIndex, time);
float amount = dynamicNoise * dynamicNoise * dynamicNoise * (1f - MathHelper.Clamp((float)(((double)num3 - 0.699999988079071 + 0.300000011920929) / 0.300000011920929), 0.0f, 1f));
vector4_1 = Vector4.Lerp(vector4_1, this._flameColor, amount);
}
}
fragment.SetColor(index, vector4_1);
}
}
}
