Add dun_render_benchmark

Results from a single run (a bit noisy) on my machine:

```
tools/build_and_run_benchmark.py dun_render_benchmark
```

```
------------------------------------------------------------------------------------------------------------------------
Benchmark                                                              Time             CPU   Iterations UserCounters...
------------------------------------------------------------------------------------------------------------------------
DunRenderBenchmark/LeftTriangle_Solid_FullyLit                     98297 ns        98282 ns         8840 items_per_second=15.1096M/s
DunRenderBenchmark/LeftTriangle_Solid_FullyDark                   124727 ns       124701 ns         6973 items_per_second=11.9085M/s
DunRenderBenchmark/LeftTriangle_Solid_PartiallyLit                514869 ns       514747 ns         1700 items_per_second=2.88491M/s
DunRenderBenchmark/LeftTriangle_Transparent_FullyLit              520312 ns       520216 ns         1682 items_per_second=2.85458M/s
DunRenderBenchmark/LeftTriangle_Transparent_FullyDark             524440 ns       524331 ns         1664 items_per_second=2.83218M/s
DunRenderBenchmark/LeftTriangle_Transparent_PartiallyLit          532300 ns       532162 ns         1647 items_per_second=2.7905M/s
DunRenderBenchmark/RightTriangle_Solid_FullyLit                    92387 ns        92363 ns         8840 items_per_second=16.7275M/s
DunRenderBenchmark/RightTriangle_Solid_FullyDark                   85680 ns        85662 ns         9884 items_per_second=18.0361M/s
DunRenderBenchmark/RightTriangle_Solid_PartiallyLit               538347 ns       538250 ns         1626 items_per_second=2.87041M/s
DunRenderBenchmark/RightTriangle_Transparent_FullyLit             548800 ns       548760 ns         1598 items_per_second=2.81544M/s
DunRenderBenchmark/RightTriangle_Transparent_FullyDark            540450 ns       540369 ns         1620 items_per_second=2.85916M/s
DunRenderBenchmark/RightTriangle_Transparent_PartiallyLit         555061 ns       555003 ns         1575 items_per_second=2.78377M/s
DunRenderBenchmark/TransparentSquare_Solid_FullyLit               700849 ns       700751 ns         1320 items_per_second=3.68176M/s
DunRenderBenchmark/TransparentSquare_Solid_FullyDark              664927 ns       664872 ns         1389 items_per_second=3.88045M/s
DunRenderBenchmark/TransparentSquare_Solid_PartiallyLit          1131702 ns      1131559 ns          822 items_per_second=2.28004M/s
DunRenderBenchmark/TransparentSquare_Transparent_FullyLit        1022384 ns      1022267 ns          916 items_per_second=2.5238M/s
DunRenderBenchmark/TransparentSquare_Transparent_FullyDark       1023193 ns      1023057 ns          900 items_per_second=2.52185M/s
DunRenderBenchmark/TransparentSquare_Transparent_PartiallyLit    1033573 ns      1033496 ns          895 items_per_second=2.49638M/s
DunRenderBenchmark/Square_Solid_FullyLit                           53532 ns        53524 ns        10000 items_per_second=30.8272M/s
DunRenderBenchmark/Square_Solid_FullyDark                          41993 ns        41987 ns        19794 items_per_second=47.1573M/s
DunRenderBenchmark/Square_Solid_PartiallyLit                      842772 ns       842615 ns         1108 items_per_second=1.56655M/s
DunRenderBenchmark/Square_Transparent_FullyLit                    834105 ns       834026 ns         1119 items_per_second=1.58269M/s
DunRenderBenchmark/Square_Transparent_FullyDark                   831912 ns       831823 ns         1122 items_per_second=1.58688M/s
DunRenderBenchmark/Square_Transparent_PartiallyLit                924638 ns       924536 ns         1010 items_per_second=1.42774M/s
DunRenderBenchmark/LeftTrapezoid_Solid_FullyLit                    33728 ns        33725 ns        24962 items_per_second=18.8583M/s
DunRenderBenchmark/LeftTrapezoid_Solid_FullyDark                   31088 ns        31085 ns        27444 items_per_second=20.4601M/s
DunRenderBenchmark/LeftTrapezoid_Solid_PartiallyLit               268792 ns       268768 ns         3254 items_per_second=1.97196M/s
DunRenderBenchmark/LeftTrapezoid_Transparent_FullyLit             277990 ns       277965 ns         3140 items_per_second=1.90672M/s
DunRenderBenchmark/LeftTrapezoid_Transparent_FullyDark            268952 ns       268912 ns         3250 items_per_second=1.9709M/s
DunRenderBenchmark/LeftTrapezoid_Transparent_PartiallyLit         288869 ns       288826 ns         3056 items_per_second=1.83501M/s
DunRenderBenchmark/RightTrapezoid_Solid_FullyLit                   29581 ns        29576 ns        28347 items_per_second=21.0984M/s
DunRenderBenchmark/RightTrapezoid_Solid_FullyDark                  25315 ns        25312 ns        32250 items_per_second=24.6523M/s
DunRenderBenchmark/RightTrapezoid_Solid_PartiallyLit              259977 ns       259960 ns         3312 items_per_second=2.0003M/s
DunRenderBenchmark/RightTrapezoid_Transparent_FullyLit            263079 ns       263056 ns         3322 items_per_second=1.97677M/s
DunRenderBenchmark/RightTrapezoid_Transparent_FullyDark           259849 ns       259824 ns         3364 items_per_second=2.00136M/s
DunRenderBenchmark/RightTrapezoid_Transparent_PartiallyLit        279623 ns       279594 ns         3127 items_per_second=1.85984M/s
```

Source/diablo.cpp

@@ -2855,6 +2855,7 @@ void LoadGameLevel(bool firstflag, lvl_entry lvldir)
 	}
 	SetRndSeed(DungeonSeeds[currlevel]);
 	IncProgress();
+	LoadTrns();
 	MakeLightTable();
 	LoadLvlGFX();
 	SetDungeonMicros();

Source/levels/gendung.h

@@ -167,7 +167,7 @@ extern WorldTileRectangle SetPiece;
 extern OptionalOwnedClxSpriteList pSpecialCels;
 /** Specifies the tile definitions of the active dungeon type; (e.g. levels/l1data/l1.til). */
 extern DVL_API_FOR_TEST std::unique_ptr<MegaTile[]> pMegaTiles;
-extern std::unique_ptr<std::byte[]> pDungeonCels;
+extern DVL_API_FOR_TEST std::unique_ptr<std::byte[]> pDungeonCels;
 /**
  * List tile properties
  */
@@ -194,7 +194,7 @@ extern std::array<bool, 256> TransList;
 /** Contains the piece IDs of each tile on the map. */
 extern DVL_API_FOR_TEST uint16_t dPiece[MAXDUNX][MAXDUNY];
 /** Map of micros that comprises a full tile for any given dungeon piece. */
-extern MICROS DPieceMicros[MAXTILES];
+extern DVL_API_FOR_TEST MICROS DPieceMicros[MAXTILES];
 /** Specifies the transparency at each coordinate of the map. */
 extern DVL_API_FOR_TEST int8_t dTransVal[MAXDUNX][MAXDUNY];
 /** Current realtime lighting. Per tile. */

Source/lighting.cpp

@@ -260,6 +260,13 @@ void DoVision(Point position, uint8_t radius, MapExplorationType doAutomap, bool
 	}
 }
 
+void LoadTrns()
+{
+	LoadFileInMem("plrgfx\\infra.trn", InfravisionTable);
+	LoadFileInMem("plrgfx\\stone.trn", StoneTable);
+	LoadFileInMem("gendata\\pause.trn", PauseTable);
+}
+
 void MakeLightTable()
 {
 	// Generate 16 gradually darker translation tables for doing lighting
@@ -319,10 +326,6 @@ void MakeLightTable()
 	assert((FullyLitLightTable != nullptr) == (LightTables[0][0] == 0 && std::adjacent_find(LightTables[0].begin(), LightTables[0].end() - 1, [](auto x, auto y) { return (x + 1) != y; }) == LightTables[0].end() - 1));
 	assert((FullyDarkLightTable != nullptr) == (std::all_of(LightTables[LightsMax].begin(), LightTables[LightsMax].end(), [](auto x) { return x == 0; })));
 
-	LoadFileInMem("plrgfx\\infra.trn", InfravisionTable);
-	LoadFileInMem("plrgfx\\stone.trn", StoneTable);
-	LoadFileInMem("gendata\\pause.trn", PauseTable);
-
 	// Generate light falloffs ranges
 	const float maxDarkness = 15;
 	const float maxBrightness = 0;

Source/lighting.h

@@ -48,11 +48,11 @@ extern Light Lights[MAXLIGHTS];
 extern std::array<uint8_t, MAXLIGHTS> ActiveLights;
 extern int ActiveLightCount;
 constexpr char LightsMax = 15;
-extern std::array<std::array<uint8_t, 256>, NumLightingLevels> LightTables;
+extern DVL_API_FOR_TEST std::array<std::array<uint8_t, 256>, NumLightingLevels> LightTables;
 /** @brief Contains a pointer to a light table that is fully lit (no color mapping is required). Can be null in hell. */
-extern uint8_t *FullyLitLightTable;
+extern DVL_API_FOR_TEST uint8_t *FullyLitLightTable;
 /** @brief Contains a pointer to a light table that is fully dark (every color result to 0/black). Can be null in hellfire levels. */
-extern uint8_t *FullyDarkLightTable;
+extern DVL_API_FOR_TEST uint8_t *FullyDarkLightTable;
 extern std::array<uint8_t, 256> InfravisionTable;
 extern std::array<uint8_t, 256> StoneTable;
 extern std::array<uint8_t, 256> PauseTable;
@@ -65,6 +65,7 @@ void DoUnLight(Point position, uint8_t radius);
 void DoLighting(Point position, uint8_t radius, DisplacementOf<int8_t> offset);
 void DoUnVision(Point position, uint8_t radius);
 void DoVision(Point position, uint8_t radius, MapExplorationType doAutomap, bool visible);
+void LoadTrns();
 void MakeLightTable();
 #ifdef _DEBUG
 void ToggleLighting();

Source/mpq/mpq_reader.cpp

@@ -40,6 +40,7 @@ MpqArchive &MpqArchive::operator=(MpqArchive &&other) noexcept
 	if (archive_ != nullptr)
 		libmpq__archive_close(archive_);
 	archive_ = other.archive_;
+	other.archive_ = nullptr;
 	tmp_buf_ = std::move(other.tmp_buf_);
 	return *this;
 }

test/CMakeLists.txt

@@ -48,7 +48,8 @@ set(standalone_tests
 )
 set(benchmarks
   clx_render_benchmark
-  crawl_benchmark)
+  crawl_benchmark
+  dun_render_benchmark)
 
 include(Fixtures.cmake)
 
@@ -88,6 +89,7 @@ target_link_libraries(codec_test PRIVATE libdevilutionx_codec app_fatal_for_test
 target_link_libraries(clx_render_benchmark PRIVATE libdevilutionx_so)
 target_link_libraries(crawl_test PRIVATE libdevilutionx_crawl)
 target_link_libraries(crawl_benchmark PRIVATE libdevilutionx_crawl)
+target_link_libraries(dun_render_benchmark PRIVATE libdevilutionx_so)
 target_link_libraries(file_util_test PRIVATE libdevilutionx_file_util app_fatal_for_testing)
 target_link_libraries(format_int_test PRIVATE libdevilutionx_format_int language_for_testing)
 target_link_libraries(parse_int_test PRIVATE libdevilutionx_parse_int)

test/dun_render_benchmark.cpp

@@ -0,0 +1,116 @@
+#include <cstddef>
+#include <span>
+
+#include <ankerl/unordered_dense.h>
+#include <benchmark/benchmark.h>
+
+#include "diablo.h"
+#include "engine/clx_sprite.hpp"
+#include "engine/displacement.hpp"
+#include "engine/load_file.hpp"
+#include "engine/render/dun_render.hpp"
+#include "engine/surface.hpp"
+#include "init.h"
+#include "levels/dun_tile.hpp"
+#include "levels/gendung.h"
+#include "lighting.h"
+#include "options.h"
+#include "utils/log.hpp"
+#include "utils/sdl_wrap.h"
+
+namespace devilution {
+namespace {
+
+SDLSurfaceUniquePtr SdlSurface;
+ankerl::unordered_dense::map<TileType, std::vector<LevelCelBlock>> Tiles;
+
+void InitOnce()
+{
+	[[maybe_unused]] static const bool GlobalInitDone = []() {
+		LoadCoreArchives();
+		LoadGameArchives();
+		if (!HaveSpawn() && !HaveDiabdat()) {
+			LogError("This benchmark needs spawn.mpq or diabdat.mpq");
+			exit(1);
+		}
+
+		leveltype = DTYPE_CATHEDRAL;
+		pDungeonCels = LoadFileInMem("levels\\l1data\\l1.cel");
+		SetDungeonMicros();
+		MakeLightTable();
+
+		SdlSurface = SDLWrap::CreateRGBSurfaceWithFormat(
+		    /*flags=*/0, /*width=*/640, /*height=*/480, /*depth=*/8, SDL_PIXELFORMAT_INDEX8);
+		if (SdlSurface == nullptr) {
+			LogError("Failed to create SDL Surface: {}", SDL_GetError());
+			exit(1);
+		}
+
+		for (size_t i = 0; i < 700; ++i) {
+			for (size_t j = 0; j < 10; ++j) {
+				if (const LevelCelBlock levelCelBlock = DPieceMicros[i].mt[j]; levelCelBlock.hasValue()) {
+					Tiles[levelCelBlock.type()].push_back(levelCelBlock);
+				}
+			}
+		}
+		return true;
+	}();
+}
+
+void RunForTileMaskLight(benchmark::State &state, TileType tileType, MaskType maskType, const uint8_t *lightTable)
+{
+	Surface out = Surface(SdlSurface.get());
+	size_t numItemsProcessed = 0;
+	const std::span<const LevelCelBlock> tiles = Tiles[tileType];
+	for (auto _ : state) {
+		for (const LevelCelBlock &levelCelBlock : tiles) {
+			RenderTile(out, Point { 320, 240 }, levelCelBlock, maskType, lightTable);
+			uint8_t color = out[Point { 310, 200 }];
+			benchmark::DoNotOptimize(color);
+		}
+		numItemsProcessed += tiles.size();
+	}
+	state.SetItemsProcessed(numItemsProcessed);
+}
+
+using GetLightTableFn = const uint8_t *();
+
+const uint8_t *FullyLit() { return FullyLitLightTable; }
+const uint8_t *FullyDark() { return FullyDarkLightTable; }
+const uint8_t *PartiallyLit() { return LightTables[5].data(); }
+
+template <TileType TileT, MaskType MaskT, GetLightTableFn GetLightTableFnT>
+void Render(benchmark::State &state)
+{
+	InitOnce();
+	RunForTileMaskLight(state, TileT, MaskT, GetLightTableFnT());
+}
+
+// Define aliases in order to have shorter benchmark names.
+constexpr auto LeftTriangle = TileType::LeftTriangle;
+constexpr auto RightTriangle = TileType::RightTriangle;
+constexpr auto TransparentSquare = TileType::TransparentSquare;
+constexpr auto Square = TileType::Square;
+constexpr auto LeftTrapezoid = TileType::LeftTrapezoid;
+constexpr auto RightTrapezoid = TileType::RightTrapezoid;
+constexpr auto Transparent = MaskType::Transparent;
+constexpr auto Solid = MaskType::Solid;
+
+#define DEFINE_FOR_TILE_AND_MASK_TYPE(TILE_TYPE, MASK_TYPE)      \
+	BENCHMARK_TEMPLATE(Render, TILE_TYPE, MASK_TYPE, FullyLit);  \
+	BENCHMARK_TEMPLATE(Render, TILE_TYPE, MASK_TYPE, FullyDark); \
+	BENCHMARK_TEMPLATE(Render, TILE_TYPE, MASK_TYPE, PartiallyLit);
+
+#define DEFINE_FOR_TILE_TYPE(TILE_TYPE)             \
+	DEFINE_FOR_TILE_AND_MASK_TYPE(TILE_TYPE, Solid) \
+	DEFINE_FOR_TILE_AND_MASK_TYPE(TILE_TYPE, Transparent)
+
+DEFINE_FOR_TILE_TYPE(LeftTriangle)
+DEFINE_FOR_TILE_TYPE(RightTriangle)
+DEFINE_FOR_TILE_TYPE(TransparentSquare)
+DEFINE_FOR_TILE_TYPE(Square)
+DEFINE_FOR_TILE_TYPE(LeftTrapezoid)
+DEFINE_FOR_TILE_TYPE(RightTrapezoid)
+
+} // namespace
+} // namespace devilution