[cmake] enable clang-cl and WoA builds (#348)

Compilation and CMake fixes for both Windows on ARM and clang-cl, meaning Windows can now be built on both MSVC and clang on both amd64 and aarch64.

Compiling on clang is *dramatically* faster so this should be useful for CI.

Co-authored-by: crueter <crueter@eden-emu.dev>
Co-authored-by: crueter <crueter@crueter.xyz>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/348
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: crueter <crueter@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

src/video_core/textures/astc.cpp

@@ -1291,7 +1291,7 @@ static void ComputeEndpoints(Pixel& ep1, Pixel& ep2, const u32*& colorValues,
     case 1: {
         READ_UINT_VALUES(2)
         u32 L0 = (v[0] >> 2) | (v[1] & 0xC0);
-        u32 L1 = std::min(L0 + (v[1] & 0x3F), 0xFFU);
+        u32 L1 = (std::min)(L0 + (v[1] & 0x3F), 0xFFU);
         ep1 = Pixel(0xFF, L0, L0, L0);
         ep2 = Pixel(0xFF, L1, L1, L1);
     } break;
@@ -1522,7 +1522,7 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
     // Read color data...
     u32 colorDataBits = remainingBits;
     while (remainingBits > 0) {
-        u32 nb = std::min(remainingBits, 8);
+        u32 nb = (std::min)(remainingBits, 8);
         u32 b = strm.ReadBits(nb);
         colorEndpointStream.WriteBits(b, nb);
         remainingBits -= 8;
@@ -1603,7 +1603,7 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
         texelWeightData[clearByteStart - 1] &=
             static_cast<u8>((1 << (weightParams.GetPackedBitSize() % 8)) - 1);
         std::memset(texelWeightData.data() + clearByteStart, 0,
-                    std::min(16U - clearByteStart, 16U));
+                    (std::min)(16U - clearByteStart, 16U));
     }
 
     IntegerEncodedVector texelWeightValues;
@@ -1674,8 +1674,8 @@ void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height,
                     std::array<u32, 12 * 12> uncompData;
                     DecompressBlock(blockPtr, block_width, block_height, uncompData);
 
-                    u32 decompWidth = std::min(block_width, width - x);
-                    u32 decompHeight = std::min(block_height, height - y);
+                    u32 decompWidth = (std::min)(block_width, width - x);
+                    u32 decompHeight = (std::min)(block_height, height - y);
 
                     const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
                     for (u32 h = 0; h < decompHeight; ++h) {

src/video_core/textures/decoders.cpp

@@ -111,13 +111,13 @@ void SwizzleSubrectImpl(std::span<u8> output, std::span<const u8> input, u32 wid
     const u32 x_shift = GOB_SIZE_SHIFT + block_height + block_depth;
 
     u32 unprocessed_lines = num_lines;
-    u32 extent_y = std::min(num_lines, height - origin_y);
+    u32 extent_y = (std::min)(num_lines, height - origin_y);
 
     for (u32 slice = 0; slice < depth; ++slice) {
         const u32 z = slice + origin_z;
         const u32 offset_z = (z >> block_depth) * slice_size +
                              ((z & block_depth_mask) << (GOB_SIZE_SHIFT + block_height));
-        const u32 lines_in_y = std::min(unprocessed_lines, extent_y);
+        const u32 lines_in_y = (std::min)(unprocessed_lines, extent_y);
         for (u32 line = 0; line < lines_in_y; ++line) {
             const u32 y = line + origin_y;
             const u32 swizzled_y = pdep<SWIZZLE_Y_BITS>(y);
@@ -180,7 +180,7 @@ void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes
                       u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth,
                       u32 stride_alignment) {
     const u32 stride = Common::AlignUpLog2(width, stride_alignment) * bytes_per_pixel;
-    const u32 new_bpp = std::min(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
+    const u32 new_bpp = (std::min)(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
     width = (width * bytes_per_pixel) >> new_bpp;
     bytes_per_pixel = 1U << new_bpp;
     Swizzle<false>(output, input, bytes_per_pixel, width, height, depth, block_height, block_depth,
@@ -191,7 +191,7 @@ void SwizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_p
                     u32 height, u32 depth, u32 block_height, u32 block_depth,
                     u32 stride_alignment) {
     const u32 stride = Common::AlignUpLog2(width, stride_alignment) * bytes_per_pixel;
-    const u32 new_bpp = std::min(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
+    const u32 new_bpp = (std::min)(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
     width = (width * bytes_per_pixel) >> new_bpp;
     bytes_per_pixel = 1U << new_bpp;
     Swizzle<true>(output, input, bytes_per_pixel, width, height, depth, block_height, block_depth,

src/video_core/textures/texture.cpp

@@ -75,7 +75,7 @@ float TSCEntry::MaxAnisotropy() const noexcept {
     if (anisotropic_settings == Settings::AnisotropyMode::Automatic) {
         added_anisotropic = Settings::values.resolution_info.up_scale >>
                             Settings::values.resolution_info.down_shift;
-        added_anisotropic = std::max(added_anisotropic - 1, 0);
+        added_anisotropic = (std::max)(added_anisotropic - 1, 0);
     } else {
         added_anisotropic = static_cast<u32>(Settings::values.max_anisotropy.GetValue()) - 1U;
     }

src/video_core/textures/workers.cpp

@@ -6,7 +6,7 @@
 namespace Tegra::Texture {
 
 Common::ThreadWorker& GetThreadWorkers() {
-    static Common::ThreadWorker workers{std::max(std::thread::hardware_concurrency(), 2U) / 2,
+    static Common::ThreadWorker workers{(std::max)(std::thread::hardware_concurrency(), 2U) / 2,
                                         "ImageTranscode"};
 
     return workers;