private void RasterInteraction(Vector2 pos, Vector2 scale, float rotation, float disp, float dist)
{
Vector2 raster = this.targetDesc.WorldToRaster(pos);
float single = -rotation * 0.0174532924f;
float single1 = Mathf.Sin(single);
float single2 = Mathf.Cos(single);
float single3 = Mathf.Min((float)this.imageDesc.width * scale.x, 1024f) * 0.5f;
float single4 = Mathf.Min((float)this.imageDesc.height * scale.y, 1024f) * 0.5f;
Vector2 vector2 = raster + this.Rotate2D(new Vector2(-single3, -single4), single1, single2);
Vector2 vector21 = raster + this.Rotate2D(new Vector2(single3, -single4), single1, single2);
Vector2 vector22 = raster + this.Rotate2D(new Vector2(single3, single4), single1, single2);
Vector2 vector23 = raster + this.Rotate2D(new Vector2(-single3, single4), single1, single2);
WaterDynamics.Point2D point2D = new WaterDynamics.Point2D(vector2.x * 256f, vector2.y * 256f);
WaterDynamics.Point2D point2D1 = new WaterDynamics.Point2D(vector21.x * 256f, vector21.y * 256f);
WaterDynamics.Point2D point2D2 = new WaterDynamics.Point2D(vector22.x * 256f, vector22.y * 256f);
WaterDynamics.Point2D point2D3 = new WaterDynamics.Point2D(vector23.x * 256f, vector23.y * 256f);
Vector2 vector24 = new Vector2(-0.5f, -0.5f);
Vector2 vector25 = new Vector2((float)this.imageDesc.width - 0.5f, -0.5f);
Vector2 vector26 = new Vector2((float)this.imageDesc.width - 0.5f, (float)this.imageDesc.height - 0.5f);
Vector2 vector27 = new Vector2(-0.5f, (float)this.imageDesc.height - 0.5f);
byte num = (byte)(disp * 255f);
byte num1 = (byte)(dist * 255f);
this.RasterizeTriangle(point2D, point2D1, point2D2, vector24, vector25, vector26, num, num1);
this.RasterizeTriangle(point2D, point2D2, point2D3, vector24, vector26, vector27, num, num1);
}
private int EdgeFunction(
WaterDynamics.Point2D a,
WaterDynamics.Point2D b,
WaterDynamics.Point2D c)
{
return((int)(((long)(b.x - a.x) * (long)(c.y - a.y) >> 8) - ((long)(b.y - a.y) * (long)(c.x - a.x) >> 8)));
}
private bool IsTopLeft(WaterDynamics.Point2D a, WaterDynamics.Point2D b)
{
if (a.y == b.y && a.x < b.x)
{
return(true);
}
return(a.y > b.y);
}
private void RasterInteraction(
Vector2 pos,
Vector2 scale,
float rotation,
float disp,
float dist)
{
Vector2 raster = this.targetDesc.WorldToRaster(pos);
double num1 = -(double)rotation * (Math.PI / 180.0);
float s = Mathf.Sin((float)num1);
float c = Mathf.Cos((float)num1);
float num2 = Mathf.Min((float)this.imageDesc.width * (float)scale.x, 1024f) * 0.5f;
float num3 = Mathf.Min((float)this.imageDesc.height * (float)scale.y, 1024f) * 0.5f;
Vector2 vector2_1 = Vector2.op_Addition(raster, this.Rotate2D(new Vector2(-num2, -num3), s, c));
Vector2 vector2_2 = Vector2.op_Addition(raster, this.Rotate2D(new Vector2(num2, -num3), s, c));
Vector2 vector2_3 = Vector2.op_Addition(raster, this.Rotate2D(new Vector2(num2, num3), s, c));
Vector2 vector2_4 = Vector2.op_Addition(raster, this.Rotate2D(new Vector2(-num2, num3), s, c));
WaterDynamics.Point2D p0 = new WaterDynamics.Point2D((float)(vector2_1.x * 256.0), (float)(vector2_1.y * 256.0));
WaterDynamics.Point2D p1 = new WaterDynamics.Point2D((float)(vector2_2.x * 256.0), (float)(vector2_2.y * 256.0));
WaterDynamics.Point2D point2D = new WaterDynamics.Point2D((float)(vector2_3.x * 256.0), (float)(vector2_3.y * 256.0));
WaterDynamics.Point2D p2 = new WaterDynamics.Point2D((float)(vector2_4.x * 256.0), (float)(vector2_4.y * 256.0));
Vector2 uv0;
((Vector2) ref uv0).\u002Ector(-0.5f, -0.5f);
Vector2 uv1;
((Vector2) ref uv1).\u002Ector((float)this.imageDesc.width - 0.5f, -0.5f);
Vector2 vector2_5;
((Vector2) ref vector2_5).\u002Ector((float)this.imageDesc.width - 0.5f, (float)this.imageDesc.height - 0.5f);
Vector2 uv2;
((Vector2) ref uv2).\u002Ector(-0.5f, (float)this.imageDesc.height - 0.5f);
byte disp1 = (byte)((double)disp * (double)byte.MaxValue);
byte dist1 = (byte)((double)dist * (double)byte.MaxValue);
this.RasterizeTriangle(p0, p1, point2D, uv0, uv1, vector2_5, disp1, dist1);
this.RasterizeTriangle(p0, point2D, p2, uv0, vector2_5, uv2, disp1, dist1);
}
private void RasterizeTriangle(WaterDynamics.Point2D p0, WaterDynamics.Point2D p1, WaterDynamics.Point2D p2, Vector2 uv0, Vector2 uv1, Vector2 uv2, byte disp, byte dist)
{
int num;
int num1 = this.imageDesc.width;
int num2 = this.imageDesc.widthShift;
int num3 = this.imageDesc.maxWidth;
int num4 = this.imageDesc.maxHeight;
int num5 = this.targetDesc.size;
int num6 = this.targetDesc.tileCount;
int num7 = Mathf.Max(this.Min3(p0.x, p1.x, p2.x), 0);
int num8 = Mathf.Max(this.Min3(p0.y, p1.y, p2.y), 0);
int num9 = Mathf.Min(this.Max3(p0.x, p1.x, p2.x), this.targetDesc.maxSizeSubStep);
int num10 = Mathf.Min(this.Max3(p0.y, p1.y, p2.y), this.targetDesc.maxSizeSubStep);
int num11 = Mathf.Max(num7 >> 8 >> (this.targetDesc.tileSizeShift & 31), 0);
int num12 = Mathf.Min(num9 >> 8 >> (this.targetDesc.tileSizeShift & 31), this.targetDesc.tileMaxCount);
int num13 = Mathf.Max(num8 >> 8 >> (this.targetDesc.tileSizeShift & 31), 0);
int num14 = Mathf.Min(num10 >> 8 >> (this.targetDesc.tileSizeShift & 31), this.targetDesc.tileMaxCount);
for (int i = num13; i <= num14; i++)
{
int num15 = i * num6;
for (int j = num11; j <= num12; j++)
{
int num16 = num15 + j;
if (this.targetDrawTileTable[num16] == 0)
{
this.targetDrawTileTable[num16] = 1;
this.targetDrawTileList.Add((ushort)num16);
}
}
}
num7 = num7 + 255 & -256;
num8 = num8 + 255 & -256;
int num17 = (this.IsTopLeft(p1, p2) ? 0 : -1);
int num18 = (this.IsTopLeft(p2, p0) ? 0 : -1);
int num19 = (this.IsTopLeft(p0, p1) ? 0 : -1);
WaterDynamics.Point2D point2D = new WaterDynamics.Point2D(num7, num8);
int num20 = this.EdgeFunction(p1, p2, point2D) + num17;
int num21 = this.EdgeFunction(p2, p0, point2D) + num18;
int num22 = this.EdgeFunction(p0, p1, point2D) + num19;
int num23 = p1.y - p2.y;
int num24 = p2.y - p0.y;
int num25 = p0.y - p1.y;
int num26 = p2.x - p1.x;
int num27 = p0.x - p2.x;
int num28 = p1.x - p0.x;
float single = 16777216f / (float)this.EdgeFunction(p0, p1, p2);
float single1 = uv0.x * 65536f;
float single2 = uv0.y * 65536f;
float single3 = (uv1.x - uv0.x) * single;
float single4 = (uv1.y - uv0.y) * single;
float single5 = (uv2.x - uv0.x) * single;
float single6 = (uv2.y - uv0.y) * single;
int num29 = (int)((float)num24 * 0.00390625f * single3 + (float)num25 * 0.00390625f * single5);
int num30 = (int)((float)num24 * 0.00390625f * single4 + (float)num25 * 0.00390625f * single6);
for (int k = num8; k <= num10; k += 256)
{
int num31 = num20;
int num32 = num21;
int num33 = num22;
int num34 = (int)(single1 + single3 * 0.00390625f * (float)num32 + single5 * 0.00390625f * (float)num33);
int num35 = (int)(single2 + single4 * 0.00390625f * (float)num32 + single6 * 0.00390625f * (float)num33);
for (int l = num7; l <= num9; l += 256)
{
if ((num31 | num32 | num33) >= 0)
{
int num36 = (num34 > 0 ? num34 : 0);
num = (num35 > 0 ? num35 : 0);
int num37 = num36 >> 16;
int num38 = num >> 16;
byte num39 = (byte)((num36 & 65535) >> 8);
byte num40 = (byte)((num & 65535) >> 8);
num37 = (num37 > 0 ? num37 : 0);
num38 = (num38 > 0 ? num38 : 0);
num37 = (num37 < num3 ? num37 : num3);
num38 = (num38 < num4 ? num38 : num4);
int num41 = (num37 < num3 ? 1 : 0);
int num42 = (num38 < num4 ? num1 : 0);
int num43 = (num38 << (num2 & 31)) + num37;
int num44 = num43 + num41;
int num45 = num43 + num42;
int num46 = num45 + num41;
byte num47 = this.imagePixels[num43];
byte num48 = this.imagePixels[num44];
byte num49 = this.imagePixels[num45];
byte num50 = this.imagePixels[num46];
int num51 = num47 + (num39 * (num48 - num47) >> 8);
int num52 = num49 + (num39 * (num50 - num49) >> 8);
int num53 = num51 + (num40 * (num52 - num51) >> 8);
num53 = num53 * disp >> 8;
int num54 = (k >> 8) * num5 + (l >> 8);
num53 = this.targetPixels[num54] + num53;
num53 = (num53 < 255 ? num53 : 255);
this.targetPixels[num54] = (byte)num53;
}
num31 += num23;
num32 += num24;
num33 += num25;
num34 += num29;
num35 += num30;
}
num20 += num26;
num21 += num27;
num22 += num28;
}
}
private void RasterizeTriangle(
WaterDynamics.Point2D p0,
WaterDynamics.Point2D p1,
WaterDynamics.Point2D p2,
Vector2 uv0,
Vector2 uv1,
Vector2 uv2,
byte disp,
byte dist)
{
int width = this.imageDesc.width;
int widthShift = this.imageDesc.widthShift;
int maxWidth = this.imageDesc.maxWidth;
int maxHeight = this.imageDesc.maxHeight;
int size = this.targetDesc.size;
int tileCount = this.targetDesc.tileCount;
int num1 = Mathf.Max(this.Min3(p0.x, p1.x, p2.x), 0);
int num2 = Mathf.Max(this.Min3(p0.y, p1.y, p2.y), 0);
int num3 = Mathf.Min(this.Max3(p0.x, p1.x, p2.x), this.targetDesc.maxSizeSubStep);
int num4 = Mathf.Min(this.Max3(p0.y, p1.y, p2.y), this.targetDesc.maxSizeSubStep);
int num5 = Mathf.Max(num1 >> 8 >> this.targetDesc.tileSizeShift, 0);
int num6 = Mathf.Min(num3 >> 8 >> this.targetDesc.tileSizeShift, this.targetDesc.tileMaxCount);
int num7 = Mathf.Max(num2 >> 8 >> this.targetDesc.tileSizeShift, 0);
int num8 = Mathf.Min(num4 >> 8 >> this.targetDesc.tileSizeShift, this.targetDesc.tileMaxCount);
for (int index1 = num7; index1 <= num8; ++index1)
{
int num9 = index1 * tileCount;
for (int index2 = num5; index2 <= num6; ++index2)
{
int index3 = num9 + index2;
if (this.targetDrawTileTable[index3] == (byte)0)
{
this.targetDrawTileTable[index3] = (byte)1;
this.targetDrawTileList.Add((ushort)index3);
}
}
}
int x = num1 + (int)byte.MaxValue & -256;
int y = num2 + (int)byte.MaxValue & -256;
int num10 = this.IsTopLeft(p1, p2) ? 0 : -1;
int num11 = this.IsTopLeft(p2, p0) ? 0 : -1;
int num12 = this.IsTopLeft(p0, p1) ? 0 : -1;
WaterDynamics.Point2D c = new WaterDynamics.Point2D(x, y);
int num13 = this.EdgeFunction(p1, p2, c) + num10;
int num14 = this.EdgeFunction(p2, p0, c) + num11;
int num15 = this.EdgeFunction(p0, p1, c) + num12;
int num16 = p1.y - p2.y;
int num17 = p2.y - p0.y;
int num18 = p0.y - p1.y;
int num19 = p2.x - p1.x;
int num20 = p0.x - p2.x;
int num21 = p1.x - p0.x;
float num22 = 1.677722E+07f / (float)this.EdgeFunction(p0, p1, p2);
float num23 = (float)(uv0.x * 65536.0);
float num24 = (float)(uv0.y * 65536.0);
float num25 = (float)(uv1.x - uv0.x) * num22;
float num26 = (float)(uv1.y - uv0.y) * num22;
float num27 = (float)(uv2.x - uv0.x) * num22;
float num28 = (float)(uv2.y - uv0.y) * num22;
int num29 = (int)((double)num17 * (1.0 / 256.0) * (double)num25 + (double)num18 * (1.0 / 256.0) * (double)num27);
int num30 = (int)((double)num17 * (1.0 / 256.0) * (double)num26 + (double)num18 * (1.0 / 256.0) * (double)num28);
for (int index1 = y; index1 <= num4; index1 += 256)
{
int num9 = num13;
int num31 = num14;
int num32 = num15;
int num33 = (int)((double)num23 + (double)num25 * (1.0 / 256.0) * (double)num31 + (double)num27 * (1.0 / 256.0) * (double)num32);
int num34 = (int)((double)num24 + (double)num26 * (1.0 / 256.0) * (double)num31 + (double)num28 * (1.0 / 256.0) * (double)num32);
for (int index2 = x; index2 <= num3; index2 += 256)
{
if ((num9 | num31 | num32) >= 0)
{
int num35 = num33 > 0 ? num33 : 0;
int num36 = num34 > 0 ? num34 : 0;
int num37 = num35 >> 16;
int num38 = num36 >> 16;
byte num39 = (byte)((num35 & (int)ushort.MaxValue) >> 8);
byte num40 = (byte)((num36 & (int)ushort.MaxValue) >> 8);
int num41 = num37 > 0 ? num37 : 0;
int num42 = num38 > 0 ? num38 : 0;
int num43 = num41 < maxWidth ? num41 : maxWidth;
int num44 = num42 < maxHeight ? num42 : maxHeight;
int num45 = num43 < maxWidth ? 1 : 0;
int num46 = num44 < maxHeight ? width : 0;
int index3 = (num44 << widthShift) + num43;
int index4 = index3 + num45;
int index5 = index3 + num46;
int index6 = index5 + num45;
byte imagePixel1 = this.imagePixels[index3];
byte imagePixel2 = this.imagePixels[index4];
byte imagePixel3 = this.imagePixels[index5];
byte imagePixel4 = this.imagePixels[index6];
int num47 = (int)imagePixel1 + ((int)num39 * ((int)imagePixel2 - (int)imagePixel1) >> 8);
int num48 = (int)imagePixel3 + ((int)num39 * ((int)imagePixel4 - (int)imagePixel3) >> 8);
int num49 = (num47 + ((int)num40 * (num48 - num47) >> 8)) * (int)disp >> 8;
int index7 = (index1 >> 8) * size + (index2 >> 8);
int num50 = (int)this.targetPixels[index7] + num49;
int num51 = num50 < (int)byte.MaxValue ? num50 : (int)byte.MaxValue;
this.targetPixels[index7] = (byte)num51;
}
num9 += num16;
num31 += num17;
num32 += num18;
num33 += num29;
num34 += num30;
}
num13 += num19;
num14 += num20;
num15 += num21;
}
}
