private unsafe void InternalPrepareDraw(Rectangle drawArea) { Rectangle rectangle; // ISSUE: explicit reference operation ((Rectangle)@rectangle).\u002Ector(drawArea.X - 2, drawArea.Y - 2, drawArea.Width + 4, drawArea.Height + 4); this._drawArea = drawArea; if (this._cache.Length < rectangle.Width * rectangle.Height + 1) { this._cache = new LiquidRenderer.LiquidCache[rectangle.Width * rectangle.Height + 1]; } if (this._drawCache.Length < drawArea.Width * drawArea.Height + 1) { this._drawCache = new LiquidRenderer.LiquidDrawCache[drawArea.Width * drawArea.Height + 1]; } if (this._waveMask.Length < drawArea.Width * drawArea.Height) { this._waveMask = new Color[drawArea.Width * drawArea.Height]; fixed(LiquidRenderer.LiquidCache *liquidCachePtr1 = &this._cache[1]) { int num1 = rectangle.Height * 2 + 2; LiquidRenderer.LiquidCache *liquidCachePtr2 = liquidCachePtr1; for (int x = (int)rectangle.X; x < rectangle.X + rectangle.Width; ++x) { for (int y = (int)rectangle.Y; y < rectangle.Y + rectangle.Height; ++y) { Tile tile = this._tiles[x, y] ?? new Tile(); liquidCachePtr2->LiquidLevel = (float)tile.liquid / (float)byte.MaxValue; liquidCachePtr2->IsHalfBrick = tile.halfBrick() && liquidCachePtr2[-1].HasLiquid; liquidCachePtr2->IsSolid = WorldGen.SolidOrSlopedTile(tile) && !liquidCachePtr2->IsHalfBrick; liquidCachePtr2->HasLiquid = (uint)tile.liquid > 0U; liquidCachePtr2->VisibleLiquidLevel = 0.0f; liquidCachePtr2->HasWall = (uint)tile.wall > 0U; liquidCachePtr2->Type = tile.liquidType(); if (liquidCachePtr2->IsHalfBrick && !liquidCachePtr2->HasLiquid) { liquidCachePtr2->Type = liquidCachePtr2[-1].Type; } ++liquidCachePtr2; } } LiquidRenderer.LiquidCache *liquidCachePtr3 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { float val1 = 0.0f; float num2; if (liquidCachePtr3->IsHalfBrick && liquidCachePtr3[-1].HasLiquid) { num2 = 1f; } else if (!liquidCachePtr3->HasLiquid) { LiquidRenderer.LiquidCache liquidCache1 = *(LiquidRenderer.LiquidCache *)((IntPtr)liquidCachePtr3 + (IntPtr) - rectangle.Height * sizeof(LiquidRenderer.LiquidCache)); LiquidRenderer.LiquidCache liquidCache2 = *(LiquidRenderer.LiquidCache *)((IntPtr)liquidCachePtr3 + (IntPtr)rectangle.Height * sizeof(LiquidRenderer.LiquidCache)); LiquidRenderer.LiquidCache liquidCache3 = liquidCachePtr3[-1]; LiquidRenderer.LiquidCache liquidCache4 = liquidCachePtr3[1]; if (liquidCache1.HasLiquid && liquidCache2.HasLiquid && (int)liquidCache1.Type == (int)liquidCache2.Type) { val1 = liquidCache1.LiquidLevel + liquidCache2.LiquidLevel; liquidCachePtr3->Type = liquidCache1.Type; } if (liquidCache3.HasLiquid && liquidCache4.HasLiquid && (int)liquidCache3.Type == (int)liquidCache4.Type) { val1 = Math.Max(val1, liquidCache3.LiquidLevel + liquidCache4.LiquidLevel); liquidCachePtr3->Type = liquidCache3.Type; } num2 = val1 * 0.5f; } else { num2 = liquidCachePtr3->LiquidLevel; } liquidCachePtr3->VisibleLiquidLevel = num2; liquidCachePtr3->HasVisibleLiquid = (double)num2 != 0.0; ++liquidCachePtr3; } liquidCachePtr3 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr4 = liquidCachePtr1; for (int index1 = 0; index1 < rectangle.Width; ++index1) { for (int index2 = 0; index2 < rectangle.Height - 10; ++index2) { if (liquidCachePtr4->HasVisibleLiquid && !liquidCachePtr4->IsSolid) { liquidCachePtr4->Opacity = 1f; liquidCachePtr4->VisibleType = liquidCachePtr4->Type; float num2 = 1f / (float)(LiquidRenderer.WATERFALL_LENGTH[(int)liquidCachePtr4->Type] + 1); float num3 = 1f; for (int index3 = 1; index3 <= LiquidRenderer.WATERFALL_LENGTH[(int)liquidCachePtr4->Type]; ++index3) { num3 -= num2; if (!liquidCachePtr4[index3].IsSolid) { liquidCachePtr4[index3].VisibleLiquidLevel = Math.Max(liquidCachePtr4[index3].VisibleLiquidLevel, liquidCachePtr4->VisibleLiquidLevel * num3); liquidCachePtr4[index3].Opacity = num3; liquidCachePtr4[index3].VisibleType = liquidCachePtr4->Type; } else { break; } } } if (liquidCachePtr4->IsSolid) { liquidCachePtr4->VisibleLiquidLevel = 1f; liquidCachePtr4->HasVisibleLiquid = false; } else { liquidCachePtr4->HasVisibleLiquid = (double)liquidCachePtr4->VisibleLiquidLevel != 0.0; } ++liquidCachePtr4; } liquidCachePtr4 += 10; } LiquidRenderer.LiquidCache *liquidCachePtr5 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (!liquidCachePtr5->HasVisibleLiquid || liquidCachePtr5->IsSolid) { liquidCachePtr5->HasLeftEdge = false; liquidCachePtr5->HasTopEdge = false; liquidCachePtr5->HasRightEdge = false; liquidCachePtr5->HasBottomEdge = false; } else { LiquidRenderer.LiquidCache liquidCache1 = liquidCachePtr5[-1]; LiquidRenderer.LiquidCache liquidCache2 = liquidCachePtr5[1]; LiquidRenderer.LiquidCache liquidCache3 = *(LiquidRenderer.LiquidCache *)((IntPtr)liquidCachePtr5 + (IntPtr) - rectangle.Height * sizeof(LiquidRenderer.LiquidCache)); LiquidRenderer.LiquidCache liquidCache4 = *(LiquidRenderer.LiquidCache *)((IntPtr)liquidCachePtr5 + (IntPtr)rectangle.Height * sizeof(LiquidRenderer.LiquidCache)); float num2 = 0.0f; float num3 = 1f; float num4 = 0.0f; float num5 = 1f; float visibleLiquidLevel = liquidCachePtr5->VisibleLiquidLevel; if (!liquidCache1.HasVisibleLiquid) { num4 += liquidCache2.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid && !liquidCache2.IsHalfBrick) { num5 -= liquidCache1.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid && !liquidCache3.IsHalfBrick) { num2 += liquidCache4.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid && !liquidCache4.IsHalfBrick) { num3 -= liquidCache3.VisibleLiquidLevel * (1f - visibleLiquidLevel); } liquidCachePtr5->LeftWall = num2; liquidCachePtr5->RightWall = num3; liquidCachePtr5->BottomWall = num5; liquidCachePtr5->TopWall = num4; Point zero = Point.get_Zero(); liquidCachePtr5->HasTopEdge = !liquidCache1.HasVisibleLiquid && !liquidCache1.IsSolid || (double)num4 != 0.0; liquidCachePtr5->HasBottomEdge = !liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid || (double)num5 != 1.0; liquidCachePtr5->HasLeftEdge = !liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid || (double)num2 != 0.0; liquidCachePtr5->HasRightEdge = !liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid || (double)num3 != 1.0; if (!liquidCachePtr5->HasLeftEdge) { if (liquidCachePtr5->HasRightEdge) { // ISSUE: explicit reference operation // ISSUE: variable of a reference type __Null& local = @zero.X; // ISSUE: cast to a reference type // ISSUE: explicit reference operation int num6 = ^ (int&)local + 32;
private unsafe void InternalPrepareDraw(Rectangle drawArea) { Rectangle rectangle = new Rectangle(drawArea.X - 2, drawArea.Y - 2, drawArea.Width + 4, drawArea.Height + 4); this._drawArea = drawArea; if (this._cache.Length < rectangle.Width * rectangle.Height + 1) { this._cache = new LiquidRenderer.LiquidCache[rectangle.Width * rectangle.Height + 1]; } if (this._drawCache.Length < drawArea.Width * drawArea.Height + 1) { this._drawCache = new LiquidRenderer.LiquidDrawCache[drawArea.Width * drawArea.Height + 1]; } if (this._waveMask.Length < drawArea.Width * drawArea.Height) { this._waveMask = new Color[drawArea.Width * drawArea.Height]; fixed(LiquidRenderer.LiquidCache *liquidCachePtr1 = &this._cache[1]) { int num1 = rectangle.Height * 2 + 2; LiquidRenderer.LiquidCache *liquidCachePtr2 = liquidCachePtr1; for (int x = rectangle.X; x < rectangle.X + rectangle.Width; ++x) { for (int y = rectangle.Y; y < rectangle.Y + rectangle.Height; ++y) { Tile tile = this._tiles[x, y] ?? new Tile(); liquidCachePtr2->LiquidLevel = (float)tile.liquid / (float)byte.MaxValue; liquidCachePtr2->IsHalfBrick = tile.halfBrick() && liquidCachePtr2[-1].HasLiquid; liquidCachePtr2->IsSolid = WorldGen.SolidOrSlopedTile(tile) && !liquidCachePtr2->IsHalfBrick; liquidCachePtr2->HasLiquid = (int)tile.liquid != 0; liquidCachePtr2->VisibleLiquidLevel = 0.0f; liquidCachePtr2->HasWall = (int)tile.wall != 0; liquidCachePtr2->Type = tile.liquidType(); if (liquidCachePtr2->IsHalfBrick && !liquidCachePtr2->HasLiquid) { liquidCachePtr2->Type = liquidCachePtr2[-1].Type; } ++liquidCachePtr2; } } LiquidRenderer.LiquidCache *liquidCachePtr3 = liquidCachePtr1 + num1; LiquidRenderer.LiquidCache liquidCache1; LiquidRenderer.LiquidCache liquidCache2; LiquidRenderer.LiquidCache liquidCache3; LiquidRenderer.LiquidCache liquidCache4; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { float val1 = 0.0f; float num2; if (liquidCachePtr3->IsHalfBrick && liquidCachePtr3[-1].HasLiquid) { num2 = 1f; } else if (!liquidCachePtr3->HasLiquid) { liquidCache1 = liquidCachePtr3[-rectangle.Height]; liquidCache2 = liquidCachePtr3[rectangle.Height]; liquidCache3 = liquidCachePtr3[-1]; liquidCache4 = liquidCachePtr3[1]; if (liquidCache1.HasLiquid && liquidCache2.HasLiquid && (int)liquidCache1.Type == (int)liquidCache2.Type) { val1 = liquidCache1.LiquidLevel + liquidCache2.LiquidLevel; liquidCachePtr3->Type = liquidCache1.Type; } if (liquidCache3.HasLiquid && liquidCache4.HasLiquid && (int)liquidCache3.Type == (int)liquidCache4.Type) { val1 = Math.Max(val1, liquidCache3.LiquidLevel + liquidCache4.LiquidLevel); liquidCachePtr3->Type = liquidCache3.Type; } num2 = val1 * 0.5f; } else { num2 = liquidCachePtr3->LiquidLevel; } liquidCachePtr3->VisibleLiquidLevel = num2; liquidCachePtr3->HasVisibleLiquid = (double)num2 != 0.0; ++liquidCachePtr3; } liquidCachePtr3 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr4 = liquidCachePtr1; for (int index1 = 0; index1 < rectangle.Width; ++index1) { for (int index2 = 0; index2 < rectangle.Height - 10; ++index2) { if (liquidCachePtr4->HasVisibleLiquid && !liquidCachePtr4->IsSolid) { liquidCachePtr4->Opacity = 1f; liquidCachePtr4->VisibleType = liquidCachePtr4->Type; float num2 = 1f / (float)(LiquidRenderer.WATERFALL_LENGTH[(int)liquidCachePtr4->Type] + 1); float num3 = 1f; for (int index3 = 1; index3 <= LiquidRenderer.WATERFALL_LENGTH[(int)liquidCachePtr4->Type]; ++index3) { num3 -= num2; if (!liquidCachePtr4[index3].IsSolid) { liquidCachePtr4[index3].VisibleLiquidLevel = Math.Max(liquidCachePtr4[index3].VisibleLiquidLevel, liquidCachePtr4->VisibleLiquidLevel * num3); liquidCachePtr4[index3].Opacity = num3; liquidCachePtr4[index3].VisibleType = liquidCachePtr4->Type; } else { break; } } } if (liquidCachePtr4->IsSolid) { liquidCachePtr4->VisibleLiquidLevel = 1f; liquidCachePtr4->HasVisibleLiquid = false; } else { liquidCachePtr4->HasVisibleLiquid = (double)liquidCachePtr4->VisibleLiquidLevel != 0.0; } ++liquidCachePtr4; } liquidCachePtr4 += 10; } LiquidRenderer.LiquidCache *liquidCachePtr5 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (!liquidCachePtr5->HasVisibleLiquid || liquidCachePtr5->IsSolid) { liquidCachePtr5->HasLeftEdge = false; liquidCachePtr5->HasTopEdge = false; liquidCachePtr5->HasRightEdge = false; liquidCachePtr5->HasBottomEdge = false; } else { liquidCache1 = liquidCachePtr5[-1]; liquidCache2 = liquidCachePtr5[1]; liquidCache3 = liquidCachePtr5[-rectangle.Height]; liquidCache4 = liquidCachePtr5[rectangle.Height]; float num2 = 0.0f; float num3 = 1f; float num4 = 0.0f; float num5 = 1f; float visibleLiquidLevel = liquidCachePtr5->VisibleLiquidLevel; if (!liquidCache1.HasVisibleLiquid) { num4 += liquidCache2.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid && !liquidCache2.IsHalfBrick) { num5 -= liquidCache1.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid && !liquidCache3.IsHalfBrick) { num2 += liquidCache4.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid && !liquidCache4.IsHalfBrick) { num3 -= liquidCache3.VisibleLiquidLevel * (1f - visibleLiquidLevel); } liquidCachePtr5->LeftWall = num2; liquidCachePtr5->RightWall = num3; liquidCachePtr5->BottomWall = num5; liquidCachePtr5->TopWall = num4; Point zero = Point.Zero; liquidCachePtr5->HasTopEdge = !liquidCache1.HasVisibleLiquid && !liquidCache1.IsSolid || (double)num4 != 0.0; liquidCachePtr5->HasBottomEdge = !liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid || (double)num5 != 1.0; liquidCachePtr5->HasLeftEdge = !liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid || (double)num2 != 0.0; liquidCachePtr5->HasRightEdge = !liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid || (double)num3 != 1.0; if (!liquidCachePtr5->HasLeftEdge) { if (liquidCachePtr5->HasRightEdge) { zero.X += 32; } else { zero.X += 16; } } if (liquidCachePtr5->HasLeftEdge && liquidCachePtr5->HasRightEdge) { zero.X = 16; zero.Y += 32; if (liquidCachePtr5->HasTopEdge) { zero.Y = 16; } } else if (!liquidCachePtr5->HasTopEdge) { if (!liquidCachePtr5->HasLeftEdge && !liquidCachePtr5->HasRightEdge) { zero.Y += 48; } else { zero.Y += 16; } } if (zero.Y == 16 && liquidCachePtr5->HasLeftEdge ^ liquidCachePtr5->HasRightEdge && (index2 + rectangle.Y) % 2 == 0) { zero.Y += 16; } liquidCachePtr5->FrameOffset = zero; } ++liquidCachePtr5; } liquidCachePtr5 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr6 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (liquidCachePtr6->HasVisibleLiquid) { liquidCache1 = liquidCachePtr6[-1]; liquidCache2 = liquidCachePtr6[1]; liquidCache3 = liquidCachePtr6[-rectangle.Height]; liquidCache4 = liquidCachePtr6[rectangle.Height]; liquidCachePtr6->VisibleLeftWall = liquidCachePtr6->LeftWall; liquidCachePtr6->VisibleRightWall = liquidCachePtr6->RightWall; liquidCachePtr6->VisibleTopWall = liquidCachePtr6->TopWall; liquidCachePtr6->VisibleBottomWall = liquidCachePtr6->BottomWall; if (liquidCache1.HasVisibleLiquid && liquidCache2.HasVisibleLiquid) { if (liquidCachePtr6->HasLeftEdge) { liquidCachePtr6->VisibleLeftWall = (float)(((double)liquidCachePtr6->LeftWall * 2.0 + (double)liquidCache1.LeftWall + (double)liquidCache2.LeftWall) * 0.25); } if (liquidCachePtr6->HasRightEdge) { liquidCachePtr6->VisibleRightWall = (float)(((double)liquidCachePtr6->RightWall * 2.0 + (double)liquidCache1.RightWall + (double)liquidCache2.RightWall) * 0.25); } } if (liquidCache3.HasVisibleLiquid && liquidCache4.HasVisibleLiquid) { if (liquidCachePtr6->HasTopEdge) { liquidCachePtr6->VisibleTopWall = (float)(((double)liquidCachePtr6->TopWall * 2.0 + (double)liquidCache3.TopWall + (double)liquidCache4.TopWall) * 0.25); } if (liquidCachePtr6->HasBottomEdge) { liquidCachePtr6->VisibleBottomWall = (float)(((double)liquidCachePtr6->BottomWall * 2.0 + (double)liquidCache3.BottomWall + (double)liquidCache4.BottomWall) * 0.25); } } } ++liquidCachePtr6; } liquidCachePtr6 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr7 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (liquidCachePtr7->HasLiquid) { liquidCache1 = liquidCachePtr7[-1]; liquidCache2 = liquidCachePtr7[1]; liquidCache3 = liquidCachePtr7[-rectangle.Height]; liquidCache4 = liquidCachePtr7[rectangle.Height]; if (liquidCachePtr7->HasTopEdge && !liquidCachePtr7->HasBottomEdge && liquidCachePtr7->HasLeftEdge ^ liquidCachePtr7->HasRightEdge) { if (liquidCachePtr7->HasRightEdge) { liquidCachePtr7->VisibleRightWall = liquidCache2.VisibleRightWall; liquidCachePtr7->VisibleTopWall = liquidCache3.VisibleTopWall; } else { liquidCachePtr7->VisibleLeftWall = liquidCache2.VisibleLeftWall; liquidCachePtr7->VisibleTopWall = liquidCache4.VisibleTopWall; } } else if (liquidCache2.FrameOffset.X == 16 && liquidCache2.FrameOffset.Y == 32) { if ((double)liquidCachePtr7->VisibleLeftWall > 0.5) { liquidCachePtr7->VisibleLeftWall = 0.0f; liquidCachePtr7->FrameOffset = new Point(0, 0); } else if ((double)liquidCachePtr7->VisibleRightWall < 0.5) { liquidCachePtr7->VisibleRightWall = 1f; liquidCachePtr7->FrameOffset = new Point(32, 0); } } } ++liquidCachePtr7; } liquidCachePtr7 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr8 = liquidCachePtr1 + num1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (liquidCachePtr8->HasLiquid) { liquidCache1 = liquidCachePtr8[-1]; liquidCache2 = liquidCachePtr8[1]; liquidCache3 = liquidCachePtr8[-rectangle.Height]; liquidCache4 = liquidCachePtr8[rectangle.Height]; if (!liquidCachePtr8->HasBottomEdge && !liquidCachePtr8->HasLeftEdge && (!liquidCachePtr8->HasTopEdge && !liquidCachePtr8->HasRightEdge)) { if (liquidCache3.HasTopEdge && liquidCache1.HasLeftEdge) { liquidCachePtr8->FrameOffset.X = Math.Max(4, (int)(16.0 - (double)liquidCache1.VisibleLeftWall * 16.0)) - 4; liquidCachePtr8->FrameOffset.Y = 48 + Math.Max(4, (int)(16.0 - (double)liquidCache3.VisibleTopWall * 16.0)) - 4; liquidCachePtr8->VisibleLeftWall = 0.0f; liquidCachePtr8->VisibleTopWall = 0.0f; liquidCachePtr8->VisibleRightWall = 1f; liquidCachePtr8->VisibleBottomWall = 1f; } else if (liquidCache4.HasTopEdge && liquidCache1.HasRightEdge) { liquidCachePtr8->FrameOffset.X = 32 - Math.Min(16, (int)((double)liquidCache1.VisibleRightWall * 16.0) - 4); liquidCachePtr8->FrameOffset.Y = 48 + Math.Max(4, (int)(16.0 - (double)liquidCache4.VisibleTopWall * 16.0)) - 4; liquidCachePtr8->VisibleLeftWall = 0.0f; liquidCachePtr8->VisibleTopWall = 0.0f; liquidCachePtr8->VisibleRightWall = 1f; liquidCachePtr8->VisibleBottomWall = 1f; } } } ++liquidCachePtr8; } liquidCachePtr8 += 4; } LiquidRenderer.LiquidCache *liquidCachePtr9 = liquidCachePtr1 + num1; fixed(LiquidRenderer.LiquidDrawCache *liquidDrawCachePtr1 = &this._drawCache[0]) fixed(Color * colorPtr1 = &this._waveMask[0]) { LiquidRenderer.LiquidDrawCache *liquidDrawCachePtr2 = liquidDrawCachePtr1; Color *colorPtr2 = colorPtr1; for (int index1 = 2; index1 < rectangle.Width - 2; ++index1) { for (int index2 = 2; index2 < rectangle.Height - 2; ++index2) { if (liquidCachePtr9->HasVisibleLiquid) { float num2 = Math.Min(0.75f, liquidCachePtr9->VisibleLeftWall); float num3 = Math.Max(0.25f, liquidCachePtr9->VisibleRightWall); float num4 = Math.Min(0.75f, liquidCachePtr9->VisibleTopWall); float num5 = Math.Max(0.25f, liquidCachePtr9->VisibleBottomWall); if (liquidCachePtr9->IsHalfBrick && (double)num5 > 0.5) { num5 = 0.5f; } liquidDrawCachePtr2->IsVisible = liquidCachePtr9->HasWall || (!liquidCachePtr9->IsHalfBrick || !liquidCachePtr9->HasLiquid); liquidDrawCachePtr2->SourceRectangle = new Rectangle((int)(16.0 - (double)num3 * 16.0) + liquidCachePtr9->FrameOffset.X, (int)(16.0 - (double)num5 * 16.0) + liquidCachePtr9->FrameOffset.Y, (int)Math.Ceiling(((double)num3 - (double)num2) * 16.0), (int)Math.Ceiling(((double)num5 - (double)num4) * 16.0)); liquidDrawCachePtr2->IsSurfaceLiquid = liquidCachePtr9->FrameOffset.X == 16 && liquidCachePtr9->FrameOffset.Y == 0 && (double)(index2 + rectangle.Y) > Main.worldSurface - 40.0; liquidDrawCachePtr2->Opacity = liquidCachePtr9->Opacity; liquidDrawCachePtr2->LiquidOffset = new Vector2((float)Math.Floor((double)num2 * 16.0), (float)Math.Floor((double)num4 * 16.0)); liquidDrawCachePtr2->Type = liquidCachePtr9->VisibleType; liquidDrawCachePtr2->HasWall = liquidCachePtr9->HasWall; byte num6 = LiquidRenderer.WAVE_MASK_STRENGTH[(int)liquidCachePtr9->VisibleType]; byte num7 = (byte)((uint)num6 >> 1); colorPtr2->R = num7; colorPtr2->G = num7; colorPtr2->B = LiquidRenderer.VISCOSITY_MASK[(int)liquidCachePtr9->VisibleType]; colorPtr2->A = num6; LiquidRenderer.LiquidCache *liquidCachePtr10 = liquidCachePtr9 - 1; if (index2 != 2 && !liquidCachePtr10->HasVisibleLiquid && (!liquidCachePtr10->IsSolid && !liquidCachePtr10->IsHalfBrick)) { *(colorPtr2 - 1) = *colorPtr2; } } else { liquidDrawCachePtr2->IsVisible = false; int index3 = liquidCachePtr9->IsSolid || liquidCachePtr9->IsHalfBrick ? 3 : 4; byte num2 = LiquidRenderer.WAVE_MASK_STRENGTH[index3]; byte num3 = (byte)((uint)num2 >> 1); colorPtr2->R = num3; colorPtr2->G = num3; colorPtr2->B = LiquidRenderer.VISCOSITY_MASK[index3]; colorPtr2->A = num2; } ++liquidCachePtr9; ++liquidDrawCachePtr2; ++colorPtr2; } liquidCachePtr9 += 4; } } LiquidRenderer.LiquidCache *liquidCachePtr11 = liquidCachePtr1; for (int x = rectangle.X; x < rectangle.X + rectangle.Width; ++x) { for (int y = rectangle.Y; y < rectangle.Y + rectangle.Height; ++y) { if ((int)liquidCachePtr11->VisibleType == 1 && liquidCachePtr11->HasVisibleLiquid && Dust.lavaBubbles < 200) { if (this._random.Next(700) == 0) { Dust.NewDust(new Vector2((float)(x * 16), (float)(y * 16)), 16, 16, 35, 0.0f, 0.0f, 0, Color.White, 1f); } if (this._random.Next(350) == 0) { int index = Dust.NewDust(new Vector2((float)(x * 16), (float)(y * 16)), 16, 8, 35, 0.0f, 0.0f, 50, Color.White, 1.5f); Main.dust[index].velocity *= 0.8f; Main.dust[index].velocity.X *= 2f; Main.dust[index].velocity.Y -= (float)this._random.Next(1, 7) * 0.1f; if (this._random.Next(10) == 0) { Main.dust[index].velocity.Y *= (float)this._random.Next(2, 5); } Main.dust[index].noGravity = true; } } ++liquidCachePtr11; } } } if (this.WaveFilters == null) { return; } this.WaveFilters(this._waveMask, this.GetCachedDrawArea()); }
// Token: 0x06000F3A RID: 3898 RVA: 0x003F2558 File Offset: 0x003F0758 private unsafe void InternalPrepareDraw(Rectangle drawArea) { Rectangle rectangle = new Rectangle(drawArea.X - 2, drawArea.Y - 2, drawArea.Width + 4, drawArea.Height + 4); this._drawArea = drawArea; if (this._cache.Length < rectangle.Width * rectangle.Height + 1) { this._cache = new LiquidRenderer.LiquidCache[rectangle.Width * rectangle.Height + 1]; } if (this._drawCache.Length < drawArea.Width * drawArea.Height + 1) { this._drawCache = new LiquidRenderer.LiquidDrawCache[drawArea.Width * drawArea.Height + 1]; } if (this._waveMask.Length < drawArea.Width * drawArea.Height) { this._waveMask = new Color[drawArea.Width * drawArea.Height]; } fixed(LiquidRenderer.LiquidCache *ptr = &this._cache[1]) { LiquidRenderer.LiquidCache *ptr2 = ptr; int num = rectangle.Height * 2 + 2; ptr2 = ptr; for (int i = rectangle.X; i < rectangle.X + rectangle.Width; i++) { for (int j = rectangle.Y; j < rectangle.Y + rectangle.Height; j++) { Tile tile = this._tiles[i, j]; if (tile == null) { tile = new Tile(); } ptr2->LiquidLevel = (float)tile.liquid / 255f; ptr2->IsHalfBrick = (tile.halfBrick() && ptr2[-1].HasLiquid); ptr2->IsSolid = (WorldGen.SolidOrSlopedTile(tile) && !ptr2->IsHalfBrick); ptr2->HasLiquid = (tile.liquid > 0); ptr2->VisibleLiquidLevel = 0f; ptr2->HasWall = (tile.wall > 0); ptr2->Type = tile.liquidType(); if (ptr2->IsHalfBrick && !ptr2->HasLiquid) { ptr2->Type = ptr2[-1].Type; } ptr2++; } } ptr2 = ptr; ptr2 += num; for (int k = 2; k < rectangle.Width - 2; k++) { for (int l = 2; l < rectangle.Height - 2; l++) { float num2 = 0f; if (ptr2->IsHalfBrick && ptr2[-1].HasLiquid) { num2 = 1f; } else if (!ptr2->HasLiquid) { LiquidRenderer.LiquidCache liquidCache = ptr2[-rectangle.Height]; LiquidRenderer.LiquidCache liquidCache2 = ptr2[rectangle.Height]; LiquidRenderer.LiquidCache liquidCache3 = ptr2[-1]; LiquidRenderer.LiquidCache liquidCache4 = ptr2[1]; if (liquidCache.HasLiquid && liquidCache2.HasLiquid && liquidCache.Type == liquidCache2.Type) { num2 = liquidCache.LiquidLevel + liquidCache2.LiquidLevel; ptr2->Type = liquidCache.Type; } if (liquidCache3.HasLiquid && liquidCache4.HasLiquid && liquidCache3.Type == liquidCache4.Type) { num2 = Math.Max(num2, liquidCache3.LiquidLevel + liquidCache4.LiquidLevel); ptr2->Type = liquidCache3.Type; } num2 *= 0.5f; } else { num2 = ptr2->LiquidLevel; } ptr2->VisibleLiquidLevel = num2; ptr2->HasVisibleLiquid = (num2 != 0f); ptr2++; } ptr2 += 4; } ptr2 = ptr; for (int m = 0; m < rectangle.Width; m++) { for (int n = 0; n < rectangle.Height - 10; n++) { if (ptr2->HasVisibleLiquid && !ptr2->IsSolid) { ptr2->Opacity = 1f; ptr2->VisibleType = ptr2->Type; float num3 = 1f / (float)(LiquidRenderer.WATERFALL_LENGTH[(int)ptr2->Type] + 1); float num4 = 1f; for (int num5 = 1; num5 <= LiquidRenderer.WATERFALL_LENGTH[(int)ptr2->Type]; num5++) { num4 -= num3; if (ptr2[num5].IsSolid) { break; } ptr2[num5].VisibleLiquidLevel = Math.Max(ptr2[num5].VisibleLiquidLevel, ptr2->VisibleLiquidLevel * num4); ptr2[num5].Opacity = num4; ptr2[num5].VisibleType = ptr2->Type; } } if (ptr2->IsSolid) { ptr2->VisibleLiquidLevel = 1f; ptr2->HasVisibleLiquid = false; } else { ptr2->HasVisibleLiquid = (ptr2->VisibleLiquidLevel != 0f); } ptr2++; } ptr2 += 10; } ptr2 = ptr; ptr2 += num; for (int num6 = 2; num6 < rectangle.Width - 2; num6++) { for (int num7 = 2; num7 < rectangle.Height - 2; num7++) { if (!ptr2->HasVisibleLiquid || ptr2->IsSolid) { ptr2->HasLeftEdge = false; ptr2->HasTopEdge = false; ptr2->HasRightEdge = false; ptr2->HasBottomEdge = false; } else { LiquidRenderer.LiquidCache liquidCache = ptr2[-1]; LiquidRenderer.LiquidCache liquidCache2 = ptr2[1]; LiquidRenderer.LiquidCache liquidCache3 = ptr2[-rectangle.Height]; LiquidRenderer.LiquidCache liquidCache4 = ptr2[rectangle.Height]; float num8 = 0f; float num9 = 1f; float num10 = 0f; float num11 = 1f; float visibleLiquidLevel = ptr2->VisibleLiquidLevel; if (!liquidCache.HasVisibleLiquid) { num10 += liquidCache2.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid && !liquidCache2.IsHalfBrick) { num11 -= liquidCache.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid && !liquidCache3.IsHalfBrick) { num8 += liquidCache4.VisibleLiquidLevel * (1f - visibleLiquidLevel); } if (!liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid && !liquidCache4.IsHalfBrick) { num9 -= liquidCache3.VisibleLiquidLevel * (1f - visibleLiquidLevel); } ptr2->LeftWall = num8; ptr2->RightWall = num9; ptr2->BottomWall = num11; ptr2->TopWall = num10; Point zero = Point.Zero; ptr2->HasTopEdge = ((!liquidCache.HasVisibleLiquid && !liquidCache.IsSolid) || num10 != 0f); ptr2->HasBottomEdge = ((!liquidCache2.HasVisibleLiquid && !liquidCache2.IsSolid) || num11 != 1f); ptr2->HasLeftEdge = ((!liquidCache3.HasVisibleLiquid && !liquidCache3.IsSolid) || num8 != 0f); ptr2->HasRightEdge = ((!liquidCache4.HasVisibleLiquid && !liquidCache4.IsSolid) || num9 != 1f); if (!ptr2->HasLeftEdge) { if (ptr2->HasRightEdge) { zero.X += 32; } else { zero.X += 16; } } if (ptr2->HasLeftEdge && ptr2->HasRightEdge) { zero.X = 16; zero.Y += 32; if (ptr2->HasTopEdge) { zero.Y = 16; } } else if (!ptr2->HasTopEdge) { if (!ptr2->HasLeftEdge && !ptr2->HasRightEdge) { zero.Y += 48; } else { zero.Y += 16; } } if (zero.Y == 16 && (ptr2->HasLeftEdge ^ ptr2->HasRightEdge) && (num7 + rectangle.Y) % 2 == 0) { zero.Y += 16; } ptr2->FrameOffset = zero; } ptr2++; } ptr2 += 4; } ptr2 = ptr; ptr2 += num; for (int num12 = 2; num12 < rectangle.Width - 2; num12++) { for (int num13 = 2; num13 < rectangle.Height - 2; num13++) { if (ptr2->HasVisibleLiquid) { LiquidRenderer.LiquidCache liquidCache = ptr2[-1]; LiquidRenderer.LiquidCache liquidCache2 = ptr2[1]; LiquidRenderer.LiquidCache liquidCache3 = ptr2[-rectangle.Height]; LiquidRenderer.LiquidCache liquidCache4 = ptr2[rectangle.Height]; ptr2->VisibleLeftWall = ptr2->LeftWall; ptr2->VisibleRightWall = ptr2->RightWall; ptr2->VisibleTopWall = ptr2->TopWall; ptr2->VisibleBottomWall = ptr2->BottomWall; if (liquidCache.HasVisibleLiquid && liquidCache2.HasVisibleLiquid) { if (ptr2->HasLeftEdge) { ptr2->VisibleLeftWall = (ptr2->LeftWall * 2f + liquidCache.LeftWall + liquidCache2.LeftWall) * 0.25f; } if (ptr2->HasRightEdge) { ptr2->VisibleRightWall = (ptr2->RightWall * 2f + liquidCache.RightWall + liquidCache2.RightWall) * 0.25f; } } if (liquidCache3.HasVisibleLiquid && liquidCache4.HasVisibleLiquid) { if (ptr2->HasTopEdge) { ptr2->VisibleTopWall = (ptr2->TopWall * 2f + liquidCache3.TopWall + liquidCache4.TopWall) * 0.25f; } if (ptr2->HasBottomEdge) { ptr2->VisibleBottomWall = (ptr2->BottomWall * 2f + liquidCache3.BottomWall + liquidCache4.BottomWall) * 0.25f; } } } ptr2++; } ptr2 += 4; } ptr2 = ptr; ptr2 += num; for (int num14 = 2; num14 < rectangle.Width - 2; num14++) { for (int num15 = 2; num15 < rectangle.Height - 2; num15++) { if (ptr2->HasLiquid) { LiquidRenderer.LiquidCache liquidCache = ptr2[-1]; LiquidRenderer.LiquidCache liquidCache2 = ptr2[1]; LiquidRenderer.LiquidCache liquidCache3 = ptr2[-rectangle.Height]; LiquidRenderer.LiquidCache liquidCache4 = ptr2[rectangle.Height]; if (ptr2->HasTopEdge && !ptr2->HasBottomEdge && (ptr2->HasLeftEdge ^ ptr2->HasRightEdge)) { if (ptr2->HasRightEdge) { ptr2->VisibleRightWall = liquidCache2.VisibleRightWall; ptr2->VisibleTopWall = liquidCache3.VisibleTopWall; } else { ptr2->VisibleLeftWall = liquidCache2.VisibleLeftWall; ptr2->VisibleTopWall = liquidCache4.VisibleTopWall; } } else if (liquidCache2.FrameOffset.X == 16 && liquidCache2.FrameOffset.Y == 32) { if (ptr2->VisibleLeftWall > 0.5f) { ptr2->VisibleLeftWall = 0f; ptr2->FrameOffset = new Point(0, 0); } else if (ptr2->VisibleRightWall < 0.5f) { ptr2->VisibleRightWall = 1f; ptr2->FrameOffset = new Point(32, 0); } } } ptr2++; } ptr2 += 4; } ptr2 = ptr; ptr2 += num; for (int num16 = 2; num16 < rectangle.Width - 2; num16++) { for (int num17 = 2; num17 < rectangle.Height - 2; num17++) { if (ptr2->HasLiquid) { LiquidRenderer.LiquidCache liquidCache = ptr2[-1]; LiquidRenderer.LiquidCache liquidCache2 = ptr2[1]; LiquidRenderer.LiquidCache liquidCache3 = ptr2[-rectangle.Height]; LiquidRenderer.LiquidCache liquidCache4 = ptr2[rectangle.Height]; if (!ptr2->HasBottomEdge && !ptr2->HasLeftEdge && !ptr2->HasTopEdge && !ptr2->HasRightEdge) { if (liquidCache3.HasTopEdge && liquidCache.HasLeftEdge) { ptr2->FrameOffset.X = Math.Max(4, (int)(16f - liquidCache.VisibleLeftWall * 16f)) - 4; ptr2->FrameOffset.Y = 48 + Math.Max(4, (int)(16f - liquidCache3.VisibleTopWall * 16f)) - 4; ptr2->VisibleLeftWall = 0f; ptr2->VisibleTopWall = 0f; ptr2->VisibleRightWall = 1f; ptr2->VisibleBottomWall = 1f; } else if (liquidCache4.HasTopEdge && liquidCache.HasRightEdge) { ptr2->FrameOffset.X = 32 - Math.Min(16, (int)(liquidCache.VisibleRightWall * 16f) - 4); ptr2->FrameOffset.Y = 48 + Math.Max(4, (int)(16f - liquidCache4.VisibleTopWall * 16f)) - 4; ptr2->VisibleLeftWall = 0f; ptr2->VisibleTopWall = 0f; ptr2->VisibleRightWall = 1f; ptr2->VisibleBottomWall = 1f; } } } ptr2++; } ptr2 += 4; } ptr2 = ptr; ptr2 += num; fixed(LiquidRenderer.LiquidDrawCache *ptr3 = &this._drawCache[0]) { fixed(Color *ptr4 = &this._waveMask[0]) { LiquidRenderer.LiquidDrawCache *ptr5 = ptr3; Color *ptr6 = ptr4; for (int num18 = 2; num18 < rectangle.Width - 2; num18++) { for (int num19 = 2; num19 < rectangle.Height - 2; num19++) { if (ptr2->HasVisibleLiquid) { float num20 = Math.Min(0.75f, ptr2->VisibleLeftWall); float num21 = Math.Max(0.25f, ptr2->VisibleRightWall); float num22 = Math.Min(0.75f, ptr2->VisibleTopWall); float num23 = Math.Max(0.25f, ptr2->VisibleBottomWall); if (ptr2->IsHalfBrick && num23 > 0.5f) { num23 = 0.5f; } ptr5->IsVisible = (ptr2->HasWall || !ptr2->IsHalfBrick || !ptr2->HasLiquid); ptr5->SourceRectangle = new Rectangle((int)(16f - num21 * 16f) + ptr2->FrameOffset.X, (int)(16f - num23 * 16f) + ptr2->FrameOffset.Y, (int)Math.Ceiling((double)((num21 - num20) * 16f)), (int)Math.Ceiling((double)((num23 - num22) * 16f))); ptr5->IsSurfaceLiquid = (ptr2->FrameOffset.X == 16 && ptr2->FrameOffset.Y == 0 && (double)(num19 + rectangle.Y) > Main.worldSurface - 40.0); ptr5->Opacity = ptr2->Opacity; ptr5->LiquidOffset = new Vector2((float)Math.Floor((double)(num20 * 16f)), (float)Math.Floor((double)(num22 * 16f))); ptr5->Type = ptr2->VisibleType; ptr5->HasWall = ptr2->HasWall; byte b = LiquidRenderer.WAVE_MASK_STRENGTH[(int)ptr2->VisibleType]; byte b2 = (byte)(b >> 1); ptr6->R = b2; ptr6->G = b2; ptr6->B = LiquidRenderer.VISCOSITY_MASK[(int)ptr2->VisibleType]; ptr6->A = b; LiquidRenderer.LiquidCache *ptr7 = ptr2 - 1; if (num19 != 2 && !ptr7->HasVisibleLiquid && !ptr7->IsSolid && !ptr7->IsHalfBrick) { *(ptr6 - 1) = *ptr6; } } else { ptr5->IsVisible = false; int num24 = (!ptr2->IsSolid && !ptr2->IsHalfBrick) ? 4 : 3; byte b3 = LiquidRenderer.WAVE_MASK_STRENGTH[num24]; byte b4 = (byte)(b3 >> 1); ptr6->R = b4; ptr6->G = b4; ptr6->B = LiquidRenderer.VISCOSITY_MASK[num24]; ptr6->A = b3; } ptr2++; ptr5++; ptr6++; } ptr2 += 4; } } } ptr2 = ptr; for (int num25 = rectangle.X; num25 < rectangle.X + rectangle.Width; num25++) { for (int num26 = rectangle.Y; num26 < rectangle.Y + rectangle.Height; num26++) { if (ptr2->VisibleType == 1 && ptr2->HasVisibleLiquid && Dust.lavaBubbles < 200) { if (this._random.Next(700) == 0) { Dust.NewDust(new Vector2((float)(num25 * 16), (float)(num26 * 16)), 16, 16, 35, 0f, 0f, 0, Color.White, 1f); } if (this._random.Next(350) == 0) { int num27 = Dust.NewDust(new Vector2((float)(num25 * 16), (float)(num26 * 16)), 16, 8, 35, 0f, 0f, 50, Color.White, 1.5f); Main.dust[num27].velocity *= 0.8f; Dust expr_11BF_cp_0_cp_0 = Main.dust[num27]; expr_11BF_cp_0_cp_0.velocity.X = expr_11BF_cp_0_cp_0.velocity.X * 2f; Dust expr_11DA_cp_0_cp_0 = Main.dust[num27]; expr_11DA_cp_0_cp_0.velocity.Y = expr_11DA_cp_0_cp_0.velocity.Y - (float)this._random.Next(1, 7) * 0.1f; if (this._random.Next(10) == 0) { Dust expr_1213_cp_0_cp_0 = Main.dust[num27]; expr_1213_cp_0_cp_0.velocity.Y = expr_1213_cp_0_cp_0.velocity.Y * (float)this._random.Next(2, 5); } Main.dust[num27].noGravity = true; } } ptr2++; } } } if (this.WaveFilters != null) { this.WaveFilters(this._waveMask, this.GetCachedDrawArea()); } }