Replace MathUtil::Clamp with std::clamp

Source/Core/AudioCommon/Mixer.cpp

@@ -4,13 +4,13 @@
 
 #include "AudioCommon/Mixer.h"
 
+#include <algorithm>
 #include <cmath>
 #include <cstring>
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 #include "Common/Swap.h"
 #include "Core/ConfigManager.h"
 
@@ -86,14 +86,14 @@ unsigned int Mixer::MixerFifo::Mix(short* samples, unsigned int numSamples,
     int sampleL = ((l1 << 16) + (l2 - l1) * (u16)m_frac) >> 16;
     sampleL = (sampleL * lvolume) >> 8;
     sampleL += samples[currentSample + 1];
-    samples[currentSample + 1] = MathUtil::Clamp(sampleL, -32767, 32767);
+    samples[currentSample + 1] = std::clamp(sampleL, -32767, 32767);
 
     s16 r1 = Common::swap16(m_buffer[(indexR + 1) & INDEX_MASK]);   // current
     s16 r2 = Common::swap16(m_buffer[(indexR2 + 1) & INDEX_MASK]);  // next
     int sampleR = ((r1 << 16) + (r2 - r1) * (u16)m_frac) >> 16;
     sampleR = (sampleR * rvolume) >> 8;
     sampleR += samples[currentSample];
-    samples[currentSample] = MathUtil::Clamp(sampleR, -32767, 32767);
+    samples[currentSample] = std::clamp(sampleR, -32767, 32767);
 
     m_frac += ratio;
     indexR += 2 * (u16)(m_frac >> 16);
@@ -111,8 +111,8 @@ unsigned int Mixer::MixerFifo::Mix(short* samples, unsigned int numSamples,
   s[1] = (s[1] * lvolume) >> 8;
   for (; currentSample < numSamples * 2; currentSample += 2)
   {
-    int sampleR = MathUtil::Clamp(s[0] + samples[currentSample + 0], -32767, 32767);
+    int sampleR = std::clamp(s[0] + samples[currentSample + 0], -32767, 32767);
-    int sampleL = MathUtil::Clamp(s[1] + samples[currentSample + 1], -32767, 32767);
+    int sampleL = std::clamp(s[1] + samples[currentSample + 1], -32767, 32767);
 
     samples[currentSample + 0] = sampleR;
     samples[currentSample + 1] = sampleL;

Source/Core/Common/MathUtil.h

@@ -18,12 +18,6 @@ namespace MathUtil
 constexpr double TAU = 6.2831853071795865;
 constexpr double PI = TAU / 2;
 
-template <class T>
-constexpr T Clamp(const T val, const T& min, const T& max)
-{
-  return std::max(min, std::min(max, val));
-}
-
 template <typename T>
 constexpr auto Sign(const T& val) -> decltype((T{} < val) - (val < T{}))
 {
@@ -81,20 +75,20 @@ struct Rectangle
   // this Clamp.
   void ClampLL(T x1, T y1, T x2, T y2)
   {
-    left = Clamp(left, x1, x2);
+    left = std::clamp(left, x1, x2);
-    right = Clamp(right, x1, x2);
+    right = std::clamp(right, x1, x2);
-    top = Clamp(top, y2, y1);
+    top = std::clamp(top, y2, y1);
-    bottom = Clamp(bottom, y2, y1);
+    bottom = std::clamp(bottom, y2, y1);
   }
 
   // If the rectangle is in a coordinate system with an upper-left origin,
   // use this Clamp.
   void ClampUL(T x1, T y1, T x2, T y2)
   {
-    left = Clamp(left, x1, x2);
+    left = std::clamp(left, x1, x2);
-    right = Clamp(right, x1, x2);
+    right = std::clamp(right, x1, x2);
-    top = Clamp(top, y1, y2);
+    top = std::clamp(top, y1, y2);
-    bottom = Clamp(bottom, y1, y2);
+    bottom = std::clamp(bottom, y1, y2);
   }
 };
 

Source/Core/Core/DSP/DSPAccelerator.cpp

@@ -2,12 +2,13 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
+
 #include "Core/DSP/DSPAccelerator.h"
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 
 namespace DSP
 {
@@ -89,7 +90,7 @@ u16 Accelerator::Read(const s16* coefs)
       temp -= 16;
 
     s32 val32 = (scale * temp) + ((0x400 + coef1 * m_yn1 + coef2 * m_yn2) >> 11);
-    val = static_cast<s16>(MathUtil::Clamp<s32>(val32, -0x7FFF, 0x7FFF));
+    val = static_cast<s16>(std::clamp<s32>(val32, -0x7FFF, 0x7FFF));
     step_size_bytes = 2;
 
     m_yn2 = m_yn1;

Source/Core/Core/HW/DSPHLE/UCodes/AX.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
+
 #include "Core/HW/DSPHLE/UCodes/AX.h"
 
 #include "Common/ChunkFile.h"
@@ -9,7 +11,6 @@
 #include "Common/File.h"
 #include "Common/FileUtil.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 #include "Common/Swap.h"
 #include "Core/HW/DSP.h"
 #include "Core/HW/DSPHLE/DSPHLE.h"
@@ -535,8 +536,8 @@ void AXUCode::OutputSamples(u32 lr_addr, u32 surround_addr)
   // Output samples clamped to 16 bits and interlaced RLRLRLRLRL...
   for (u32 i = 0; i < 5 * 32; ++i)
   {
-    int left = MathUtil::Clamp(m_samples_left[i], -32767, 32767);
+    int left = std::clamp(m_samples_left[i], -32767, 32767);
-    int right = MathUtil::Clamp(m_samples_right[i], -32767, 32767);
+    int right = std::clamp(m_samples_right[i], -32767, 32767);
 
     buffer[2 * i + 0] = Common::swap16(right);
     buffer[2 * i + 1] = Common::swap16(left);

Source/Core/Core/HW/DSPHLE/UCodes/AXVoice.h

@@ -12,11 +12,11 @@
 #error AXVoice.h included without specifying version
 #endif
 
+#include <algorithm>
 #include <functional>
 #include <memory>
 
 #include "Common/CommonTypes.h"
-#include "Common/MathUtil.h"
 #include "Core/DSP/DSPAccelerator.h"
 #include "Core/HW/DSP.h"
 #include "Core/HW/DSPHLE/UCodes/AX.h"
@@ -413,7 +413,7 @@ void MixAdd(int* out, const s16* input, u32 count, u16* pvol, s16* dpop, bool ra
     s64 sample = input[i];
     sample *= volume;
     sample >>= 15;
-    sample = MathUtil::Clamp((s32)sample, -32767, 32767);  // -32768 ?
+    sample = std::clamp((s32)sample, -32767, 32767);  // -32768 ?
 
     out[i] += (s16)sample;
     volume += volume_delta;
@@ -447,7 +447,7 @@ void ProcessVoice(PB_TYPE& pb, const AXBuffers& buffers, u16 count, AXMixControl
   // Apply a global volume ramp using the volume envelope parameters.
   for (u32 i = 0; i < count; ++i)
   {
-    samples[i] = MathUtil::Clamp(((s32)samples[i] * pb.vol_env.cur_volume) >> 15, -32767,
+    samples[i] = std::clamp(((s32)samples[i] * pb.vol_env.cur_volume) >> 15, -32767,
                             32767);  // -32768 ?
     pb.vol_env.cur_volume += pb.vol_env.cur_volume_delta;
   }

Source/Core/Core/HW/DSPHLE/UCodes/AXWii.cpp

@@ -4,12 +4,13 @@
 //
 #define AX_WII  // Used in AXVoice.
 
+#include <algorithm>
+
 #include "Core/HW/DSPHLE/UCodes/AXWii.h"
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 #include "Common/Swap.h"
 #include "Core/HW/DSPHLE/DSPHLE.h"
 #include "Core/HW/DSPHLE/MailHandler.h"
@@ -602,8 +603,8 @@ void AXWiiUCode::OutputSamples(u32 lr_addr, u32 surround_addr, u16 volume, bool
     left = ((s64)left * volume_ramp[i]) >> 15;
     right = ((s64)right * volume_ramp[i]) >> 15;
 
-    m_samples_left[i] = MathUtil::Clamp(left, -32767, 32767);
+    m_samples_left[i] = std::clamp(left, -32767, 32767);
-    m_samples_right[i] = MathUtil::Clamp(right, -32767, 32767);
+    m_samples_right[i] = std::clamp(right, -32767, 32767);
   }
 
   for (u32 i = 0; i < 3 * 32; ++i)
@@ -626,7 +627,7 @@ void AXWiiUCode::OutputWMSamples(u32* addresses)
     u16* out = (u16*)HLEMemory_Get_Pointer(addresses[i]);
     for (u32 j = 0; j < 3 * 6; ++j)
     {
-      int sample = MathUtil::Clamp(in[j], -32767, 32767);
+      int sample = std::clamp(in[j], -32767, 32767);
       out[j] = Common::swap16((u16)sample);
     }
   }

Source/Core/Core/HW/DSPHLE/UCodes/Zelda.cpp

@@ -4,6 +4,7 @@
 
 #include "Core/HW/DSPHLE/UCodes/Zelda.h"
 
+#include <algorithm>
 #include <array>
 #include <map>
 
@@ -1086,7 +1087,7 @@ void ZeldaAudioRenderer::ApplyReverb(bool post_rendering)
           for (u16 j = 0; j < 8; ++j)
             sample += (s32)buffer[i + j] * rpb.filter_coeffs[j];
           sample >>= 15;
-          buffer[i] = MathUtil::Clamp(sample, -0x8000, 0x7FFF);
+          buffer[i] = std::clamp(sample, -0x8000, 0x7FFF);
         }
       };
 
@@ -1526,7 +1527,7 @@ void ZeldaAudioRenderer::Resample(VPB* vpb, const s16* src, MixingBuffer* dst)
         dst_sample_unclamped += (s64)2 * coeffs[i] * input[i];
       dst_sample_unclamped >>= 16;
 
-      dst_sample = (s16)MathUtil::Clamp<s64>(dst_sample_unclamped, -0x8000, 0x7FFF);
+      dst_sample = (s16)std::clamp<s64>(dst_sample_unclamped, -0x8000, 0x7FFF);
 
       pos += ratio;
     }
@@ -1764,7 +1765,7 @@ void ZeldaAudioRenderer::DecodeAFC(VPB* vpb, s16* dst, size_t block_count)
       s32 sample =
           delta * nibbles[i] + yn1 * m_afc_coeffs[idx * 2] + yn2 * m_afc_coeffs[idx * 2 + 1];
       sample >>= 11;
-      sample = MathUtil::Clamp(sample, -0x8000, 0x7fff);
+      sample = std::clamp(sample, -0x8000, 0x7fff);
       *dst++ = (s16)sample;
       yn2 = yn1;
       yn1 = sample;

Source/Core/Core/HW/DSPHLE/UCodes/Zelda.h

@@ -4,10 +4,10 @@
 
 #pragma once
 
+#include <algorithm>
 #include <array>
 
 #include "Common/CommonTypes.h"
-#include "Common/MathUtil.h"
 #include "Core/HW/DSPHLE/UCodes/UCodes.h"
 
 namespace DSP
@@ -54,7 +54,7 @@ private:
       s32 tmp = (u32)(*buf)[i] * (u32)vol;
       tmp >>= 16 - B;
 
-      (*buf)[i] = (s16)MathUtil::Clamp(tmp, -0x8000, 0x7FFF);
+      (*buf)[i] = (s16)std::clamp(tmp, -0x8000, 0x7FFF);
     }
   }
   template <size_t N>
@@ -96,7 +96,7 @@ private:
     while (count--)
     {
       s32 vol_src = ((s32)*src++ * (s32)vol) >> 15;
-      *dst++ += MathUtil::Clamp(vol_src, -0x8000, 0x7FFF);
+      *dst++ += std::clamp(vol_src, -0x8000, 0x7FFF);
     }
   }
 

Source/Core/Core/HW/GCMemcard/GCMemcard.cpp

@@ -15,7 +15,6 @@
 #include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
 #include "Common/File.h"
-#include "Common/MathUtil.h"
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
 #include "Common/Swap.h"
@@ -609,8 +608,8 @@ u16 BlockAlloc::NextFreeBlock(u16 MaxBlock, u16 StartingBlock) const
 {
   if (m_free_blocks > 0)
   {
-    StartingBlock = MathUtil::Clamp<u16>(StartingBlock, MC_FST_BLOCKS, BAT_SIZE + MC_FST_BLOCKS);
+    StartingBlock = std::clamp<u16>(StartingBlock, MC_FST_BLOCKS, BAT_SIZE + MC_FST_BLOCKS);
-    MaxBlock = MathUtil::Clamp<u16>(MaxBlock, MC_FST_BLOCKS, BAT_SIZE + MC_FST_BLOCKS);
+    MaxBlock = std::clamp<u16>(MaxBlock, MC_FST_BLOCKS, BAT_SIZE + MC_FST_BLOCKS);
     for (u16 i = StartingBlock; i < MaxBlock; ++i)
       if (m_map[i - MC_FST_BLOCKS] == 0)
         return i;

Source/Core/Core/HW/StreamADPCM.cpp

@@ -4,11 +4,12 @@
 
 // Adapted from in_cube by hcs & destop
 
+#include <algorithm>
+
 #include "Core/HW/StreamADPCM.h"
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
-#include "Common/MathUtil.h"
 
 namespace StreamADPCM
 {
@@ -30,7 +31,7 @@ static s16 ADPDecodeSample(s32 bits, s32 q, s32& hist1, s32& hist2)
     hist = (hist1 * 0x62) - (hist2 * 0x37);
     break;
   }
-  hist = MathUtil::Clamp((hist + 0x20) >> 6, -0x200000, 0x1fffff);
+  hist = std::clamp((hist + 0x20) >> 6, -0x200000, 0x1fffff);
 
   s32 cur = (((s16)(bits << 12) >> (q & 0xf)) << 6) + hist;
 
@@ -38,7 +39,7 @@ static s16 ADPDecodeSample(s32 bits, s32 q, s32& hist1, s32& hist2)
   hist1 = cur;
 
   cur >>= 6;
-  cur = MathUtil::Clamp(cur, -0x8000, 0x7fff);
+  cur = std::clamp(cur, -0x8000, 0x7fff);
 
   return (s16)cur;
 }

Source/Core/Core/HW/VideoInterface.cpp

@@ -4,6 +4,7 @@
 
 #include "Core/HW/VideoInterface.h"
 
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <cstddef>
@@ -12,7 +13,6 @@
 #include "Common/CommonTypes.h"
 #include "Common/Config/Config.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 
 #include "Core/Config/MainSettings.h"
 #include "Core/Config/SYSCONFSettings.h"
@@ -328,7 +328,7 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
         u16 value = static_cast<u16>(1 + m_HTiming0.HLW *
                                              (CoreTiming::GetTicks() - s_ticks_last_line_start) /
                                              (GetTicksPerHalfLine()));
-        return MathUtil::Clamp(value, static_cast<u16>(1), static_cast<u16>(m_HTiming0.HLW * 2));
+        return std::clamp<u16>(value, 1, m_HTiming0.HLW * 2);
       }),
       MMIO::ComplexWrite<u16>([](u32, u16 val) {
         WARN_LOG(VIDEOINTERFACE,

Source/Core/Core/HW/WiimoteEmu/Dynamics.cpp

@@ -4,6 +4,7 @@
 
 #include "Core/HW/WiimoteEmu/Dynamics.h"
 
+#include <algorithm>
 #include <cmath>
 
 #include "Common/MathUtil.h"
@@ -170,7 +171,7 @@ void EmulateSwing(MotionState* state, ControllerEmu::Force* swing_group, float t
   if (y_progress > max_y_progress || y_progress < -1)
   {
     state->position.y =
-        MathUtil::Clamp(state->position.y, -1.f * max_distance, max_y_progress * max_distance);
+        std::clamp(state->position.y, -1.f * max_distance, max_y_progress * max_distance);
     state->velocity.y = 0;
     state->acceleration.y = 0;
   }
@@ -184,9 +185,9 @@ WiimoteCommon::DataReportBuilder::AccelData ConvertAccelData(const Common::Vec3&
   // 10-bit integers.
   constexpr long MAX_VALUE = (1 << 10) - 1;
 
-  return {u16(MathUtil::Clamp(std::lround(scaled_accel.x + zero_g), 0l, MAX_VALUE)),
+  return {u16(std::clamp(std::lround(scaled_accel.x + zero_g), 0l, MAX_VALUE)),
-          u16(MathUtil::Clamp(std::lround(scaled_accel.y + zero_g), 0l, MAX_VALUE)),
+          u16(std::clamp(std::lround(scaled_accel.y + zero_g), 0l, MAX_VALUE)),
-          u16(MathUtil::Clamp(std::lround(scaled_accel.z + zero_g), 0l, MAX_VALUE))};
+          u16(std::clamp(std::lround(scaled_accel.z + zero_g), 0l, MAX_VALUE))};
 }
 
 void EmulateCursor(MotionState* state, ControllerEmu::Cursor* ir_group, float time_elapsed)

Source/Core/Core/HW/WiimoteEmu/Extension/Nunchuk.cpp

@@ -4,6 +4,7 @@
 
 #include "Core/HW/WiimoteEmu/Extension/Nunchuk.h"
 
+#include <algorithm>
 #include <array>
 #include <cassert>
 #include <cstring>

Source/Core/Core/HW/WiimoteEmu/MotionPlus.cpp

@@ -642,9 +642,9 @@ void MotionPlus::PrepareInput(const Common::Vec3& angular_velocity)
     mplus_data.pitch_slow = (std::abs(pitch) < SLOW_MAX_RAD_PER_SEC);
     s32 pitch_value = pitch * (mplus_data.pitch_slow ? SLOW_SCALE : FAST_SCALE);
 
-    yaw_value = MathUtil::Clamp(yaw_value + ZERO_VALUE, 0, MAX_VALUE);
+    yaw_value = std::clamp(yaw_value + ZERO_VALUE, 0, MAX_VALUE);
-    roll_value = MathUtil::Clamp(roll_value + ZERO_VALUE, 0, MAX_VALUE);
+    roll_value = std::clamp(roll_value + ZERO_VALUE, 0, MAX_VALUE);
-    pitch_value = MathUtil::Clamp(pitch_value + ZERO_VALUE, 0, MAX_VALUE);
+    pitch_value = std::clamp(pitch_value + ZERO_VALUE, 0, MAX_VALUE);
 
     // Bits 0-7
     mplus_data.yaw1 = u8(yaw_value);

Source/Core/Core/PowerPC/Interpreter/Interpreter_LoadStorePaired.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -63,7 +64,7 @@ SType ScaleAndClamp(double ps, u32 stScale)
   float min = (float)std::numeric_limits<SType>::min();
   float max = (float)std::numeric_limits<SType>::max();
 
-  return (SType)MathUtil::Clamp(convPS, min, max);
+  return (SType)std::clamp(convPS, min, max);
 }
 
 template <typename T>

Source/Core/InputCommon/ControllerEmu/ControlGroup/Cursor.cpp

@@ -109,7 +109,7 @@ Cursor::StateData Cursor::GetState(const bool adjusted)
 
   // Smooth out z movement:
   // FYI: Not using relative input for Z.
-  m_state.z += MathUtil::Clamp(z - m_state.z, -max_z_step, max_z_step);
+  m_state.z += std::clamp(z - m_state.z, -max_z_step, max_z_step);
 
   // Relative input:
   if (m_relative_setting.GetValue())
@@ -122,8 +122,8 @@ Cursor::StateData Cursor::GetState(const bool adjusted)
     }
     else
     {
-      m_state.x = MathUtil::Clamp(m_state.x + input.x * max_step, -1.0, 1.0);
+      m_state.x = std::clamp(m_state.x + input.x * max_step, -1.0, 1.0);
-      m_state.y = MathUtil::Clamp(m_state.y + input.y * max_step, -1.0, 1.0);
+      m_state.y = std::clamp(m_state.y + input.y * max_step, -1.0, 1.0);
     }
   }
   // Absolute input:

Source/Core/InputCommon/ControllerEmu/StickGate.cpp

@@ -4,6 +4,7 @@
 
 #include "InputCommon/ControllerEmu/StickGate.h"
 
+#include <algorithm>
 #include <cmath>
 
 #include "Common/Common.h"
@@ -277,8 +278,8 @@ ReshapableInput::ReshapeData ReshapableInput::Reshape(ControlState x, ControlSta
   // Scale to the gate shape/radius:
   dist *= gate_max_dist;
 
-  return {MathUtil::Clamp(std::cos(angle) * dist, -1.0, 1.0),
+  return {std::clamp(std::cos(angle) * dist, -1.0, 1.0),
-          MathUtil::Clamp(std::sin(angle) * dist, -1.0, 1.0)};
+          std::clamp(std::sin(angle) * dist, -1.0, 1.0)};
 }
 
 }  // namespace ControllerEmu

Source/Core/InputCommon/ControllerInterface/Pipes/Pipes.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <array>
 #include <cstdlib>
 #include <fcntl.h>
@@ -15,7 +16,6 @@
 #include <vector>
 
 #include "Common/FileUtil.h"
-#include "Common/MathUtil.h"
 #include "Common/StringUtil.h"
 #include "InputCommon/ControllerInterface/ControllerInterface.h"
 #include "InputCommon/ControllerInterface/Pipes/Pipes.h"
@@ -123,7 +123,7 @@ void PipeDevice::AddAxis(const std::string& name, double value)
 
 void PipeDevice::SetAxis(const std::string& entry, double value)
 {
-  value = MathUtil::Clamp(value, 0.0, 1.0);
+  value = std::clamp(value, 0.0, 1.0);
   double hi = std::max(0.0, value - 0.5) * 2.0;
   double lo = (0.5 - std::min(0.5, value)) * 2.0;
   auto search_hi = m_axes.find(entry + " +");

Source/Core/InputCommon/ControllerInterface/evdev/evdev.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <cstring>
 #include <fcntl.h>
 #include <libudev.h>

Source/Core/VideoBackends/D3D/Render.cpp

@@ -4,6 +4,7 @@
 
 #include "VideoBackends/D3D/Render.h"
 
+#include <algorithm>
 #include <array>
 #include <cinttypes>
 #include <cmath>

Source/Core/VideoBackends/Software/EfbInterface.cpp

@@ -514,7 +514,7 @@ static u32 GammaCorrection(u32 color, const float gamma_rcp)
   for (int i = BLU_C; i <= RED_C; i++)
   {
     out_color[i] = static_cast<u8>(
-        MathUtil::Clamp(std::pow(in_colors[i] / 255.0f, gamma_rcp) * 255.0f, 0.0f, 255.0f));
+        std::clamp(std::pow(in_colors[i] / 255.0f, gamma_rcp) * 255.0f, 0.0f, 255.0f));
   }
 
   u32 out_color32;

Source/Core/VideoBackends/Software/Rasterizer.cpp

@@ -77,7 +77,7 @@ static void Draw(s32 x, s32 y, s32 xi, s32 yi)
   float dx = vertexOffsetX + (float)(x - vertex0X);
   float dy = vertexOffsetY + (float)(y - vertex0Y);
 
-  s32 z = (s32)MathUtil::Clamp<float>(ZSlope.GetValue(dx, dy), 0.0f, 16777215.0f);
+  s32 z = (s32)std::clamp<float>(ZSlope.GetValue(dx, dy), 0.0f, 16777215.0f);
 
   if (bpmem.UseEarlyDepthTest() && g_ActiveConfig.bZComploc)
   {

Source/Core/VideoBackends/Software/Tev.cpp

@@ -2,11 +2,11 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <cmath>
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
-#include "Common/MathUtil.h"
 #include "VideoBackends/Software/DebugUtil.h"
 #include "VideoBackends/Software/EfbInterface.h"
 #include "VideoBackends/Software/Tev.h"
@@ -777,7 +777,7 @@ void Tev::Draw()
       // Based on that, choose the index such that points which are far away from the z-axis use the
       // 10th "k" value and such that central points use the first value.
       float floatindex = 9.f - std::abs(offset) * 9.f;
-      floatindex = MathUtil::Clamp(floatindex, 0.f, 9.f);  // TODO: This shouldn't be necessary!
+      floatindex = std::clamp(floatindex, 0.f, 9.f);  // TODO: This shouldn't be necessary!
 
       // Get the two closest integer indices, look up the corresponding samples
       const int indexlower = (int)floatindex;
@@ -798,7 +798,7 @@ void Tev::Draw()
     ze -= bpmem.fog.GetC();
 
     // clamp 0 to 1
-    float fog = MathUtil::Clamp(ze, 0.f, 1.f);
+    float fog = std::clamp(ze, 0.f, 1.f);
 
     switch (bpmem.fog.c_proj_fsel.fsel)
     {

Source/Core/VideoBackends/Software/TransformUnit.cpp

@@ -12,7 +12,6 @@
 #include "Common/Assert.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
 #include "Common/MsgHandler.h"
 #include "Common/Swap.h"
 
@@ -192,8 +191,8 @@ static void TransformTexCoordRegular(const TexMtxInfo& texinfo, int coordNum, bo
   // Makes differences in Rogue Squadron 3 (Hoth sky) and The Last Story (shadow culling)
   if (dst->z == 0.0f)
   {
-    dst->x = MathUtil::Clamp(dst->x / 2.0f, -1.0f, 1.0f);
+    dst->x = std::clamp(dst->x / 2.0f, -1.0f, 1.0f);
-    dst->y = MathUtil::Clamp(dst->y / 2.0f, -1.0f, 1.0f);
+    dst->y = std::clamp(dst->y / 2.0f, -1.0f, 1.0f);
   }
 }
 
@@ -359,9 +358,9 @@ void TransformColor(const InputVertexData* src, OutputVertexData* dst)
           LightColor(dst->mvPosition, dst->normal[0], i, colorchan, lightCol);
       }
 
-      int light_x = MathUtil::Clamp(static_cast<int>(lightCol.x), 0, 255);
+      int light_x = std::clamp(static_cast<int>(lightCol.x), 0, 255);
-      int light_y = MathUtil::Clamp(static_cast<int>(lightCol.y), 0, 255);
+      int light_y = std::clamp(static_cast<int>(lightCol.y), 0, 255);
-      int light_z = MathUtil::Clamp(static_cast<int>(lightCol.z), 0, 255);
+      int light_z = std::clamp(static_cast<int>(lightCol.z), 0, 255);
       chancolor[1] = (matcolor[1] * (light_x + (light_x >> 7))) >> 8;
       chancolor[2] = (matcolor[2] * (light_y + (light_y >> 7))) >> 8;
       chancolor[3] = (matcolor[3] * (light_z + (light_z >> 7))) >> 8;
@@ -393,7 +392,7 @@ void TransformColor(const InputVertexData* src, OutputVertexData* dst)
           LightAlpha(dst->mvPosition, dst->normal[0], i, alphachan, lightCol);
       }
 
-      int light_a = MathUtil::Clamp(static_cast<int>(lightCol), 0, 255);
+      int light_a = std::clamp(static_cast<int>(lightCol), 0, 255);
       chancolor[0] = (matcolor[0] * (light_a + (light_a >> 7))) >> 8;
     }
     else

Source/Core/VideoBackends/Vulkan/SwapChain.cpp

@@ -267,9 +267,9 @@ bool SwapChain::CreateSwapChain()
     size.width = std::max(g_renderer->GetBackbufferWidth(), 1);
     size.height = std::max(g_renderer->GetBackbufferHeight(), 1);
   }
-  size.width = MathUtil::Clamp(size.width, surface_capabilities.minImageExtent.width,
+  size.width = std::clamp(size.width, surface_capabilities.minImageExtent.width,
                           surface_capabilities.maxImageExtent.width);
-  size.height = MathUtil::Clamp(size.height, surface_capabilities.minImageExtent.height,
+  size.height = std::clamp(size.height, surface_capabilities.minImageExtent.height,
                            surface_capabilities.maxImageExtent.height);
 
   // Prefer identity transform if possible

Source/Core/VideoCommon/BPFunctions.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <algorithm>
+
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 
@@ -90,8 +92,8 @@ void SetViewport()
   {
     // There's no way to support oversized depth ranges in this situation. Let's just clamp the
     // range to the maximum value supported by the console GPU and hope for the best.
-    min_depth = MathUtil::Clamp(min_depth, 0.0f, GX_MAX_DEPTH);
+    min_depth = std::clamp(min_depth, 0.0f, GX_MAX_DEPTH);
-    max_depth = MathUtil::Clamp(max_depth, 0.0f, GX_MAX_DEPTH);
+    max_depth = std::clamp(max_depth, 0.0f, GX_MAX_DEPTH);
   }
 
   if (g_renderer->UseVertexDepthRange())
@@ -131,10 +133,10 @@ void SetViewport()
   {
     const float max_width = static_cast<float>(g_renderer->GetCurrentFramebuffer()->GetWidth());
     const float max_height = static_cast<float>(g_renderer->GetCurrentFramebuffer()->GetHeight());
-    x = MathUtil::Clamp(x, 0.0f, max_width - 1.0f);
+    x = std::clamp(x, 0.0f, max_width - 1.0f);
-    y = MathUtil::Clamp(y, 0.0f, max_height - 1.0f);
+    y = std::clamp(y, 0.0f, max_height - 1.0f);
-    width = MathUtil::Clamp(width, 1.0f, max_width - x);
+    width = std::clamp(width, 1.0f, max_width - x);
-    height = MathUtil::Clamp(height, 1.0f, max_height - y);
+    height = std::clamp(height, 1.0f, max_height - y);
   }
 
   // Lower-left flip.

Source/Core/VideoCommon/RenderBase.cpp

@@ -14,6 +14,7 @@
 
 #include "VideoCommon/RenderBase.h"
 
+#include <algorithm>
 #include <cinttypes>
 #include <cmath>
 #include <memory>
@@ -218,11 +219,11 @@ u32 Renderer::AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data)
     if (bpmem.zcontrol.pixel_format == PEControl::RGB565_Z16)
     {
       // if Z is in 16 bit format you must return a 16 bit integer
-      ret = MathUtil::Clamp<u32>(static_cast<u32>(depth * 65536.0f), 0, 0xFFFF);
+      ret = std::clamp<u32>(static_cast<u32>(depth * 65536.0f), 0, 0xFFFF);
     }
     else
     {
-      ret = MathUtil::Clamp<u32>(static_cast<u32>(depth * 16777216.0f), 0, 0xFFFFFF);
+      ret = std::clamp<u32>(static_cast<u32>(depth * 16777216.0f), 0, 0xFFFFFF);
     }
 
     return ret;

Source/Core/VideoCommon/TextureCacheBase.cpp

@@ -556,7 +556,7 @@ static void SetSamplerState(u32 index, float custom_tex_scale, bool custom_tex,
     // distance they kick in at is important to preserve at any resolution.
     // Correct this with the upscaling factor of custom textures.
     s64 lod_offset = std::log2(g_renderer->GetEFBScale() / custom_tex_scale) * 256.f;
-    state.lod_bias = MathUtil::Clamp<s64>(state.lod_bias + lod_offset, -32768, 32767);
+    state.lod_bias = std::clamp<s64>(state.lod_bias + lod_offset, -32768, 32767);
 
     // Anisotropic also pushes mips farther away so it cannot be used either
     state.anisotropic_filtering = 0;

Source/Core/VideoCommon/TextureDecoder_Common.cpp

@@ -7,7 +7,6 @@
 #include <cstddef>
 
 #include "Common/CommonTypes.h"
-#include "Common/MathUtil.h"
 #include "Common/MsgHandler.h"
 #include "Common/Swap.h"
 
@@ -705,9 +704,9 @@ void TexDecoder_DecodeTexel(u8* dst, const u8* src, int s, int t, int imageWidth
 
     // We do the inverse BT.601 conversion for YCbCr to RGB
     // http://www.equasys.de/colorconversion.html#YCbCr-RGBColorFormatConversion
-    u8 R = MathUtil::Clamp(int(1.164f * Y + 1.596f * V), 0, 255);
+    u8 R = std::clamp(int(1.164f * Y + 1.596f * V), 0, 255);
-    u8 G = MathUtil::Clamp(int(1.164f * Y - 0.392f * U - 0.813f * V), 0, 255);
+    u8 G = std::clamp(int(1.164f * Y - 0.392f * U - 0.813f * V), 0, 255);
-    u8 B = MathUtil::Clamp(int(1.164f * Y + 2.017f * U), 0, 255);
+    u8 B = std::clamp(int(1.164f * Y + 2.017f * U), 0, 255);
     dst[t * imageWidth + s] = 0xff000000 | B << 16 | G << 8 | R;
   }
   break;
@@ -770,13 +769,13 @@ void TexDecoder_DecodeXFB(u8* dst, const u8* src, u32 width, u32 height, u32 str
 
       // We do the inverse BT.601 conversion for YCbCr to RGB
       // http://www.equasys.de/colorconversion.html#YCbCr-RGBColorFormatConversion
-      u8 R1 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y1 + 1.596f * V), 0, 255));
+      u8 R1 = static_cast<u8>(std::clamp(int(1.164f * Y1 + 1.596f * V), 0, 255));
-      u8 G1 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y1 - 0.392f * U - 0.813f * V), 0, 255));
+      u8 G1 = static_cast<u8>(std::clamp(int(1.164f * Y1 - 0.392f * U - 0.813f * V), 0, 255));
-      u8 B1 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y1 + 2.017f * U), 0, 255));
+      u8 B1 = static_cast<u8>(std::clamp(int(1.164f * Y1 + 2.017f * U), 0, 255));
 
-      u8 R2 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y2 + 1.596f * V), 0, 255));
+      u8 R2 = static_cast<u8>(std::clamp(int(1.164f * Y2 + 1.596f * V), 0, 255));
-      u8 G2 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y2 - 0.392f * U - 0.813f * V), 0, 255));
+      u8 G2 = static_cast<u8>(std::clamp(int(1.164f * Y2 - 0.392f * U - 0.813f * V), 0, 255));
-      u8 B2 = static_cast<u8>(MathUtil::Clamp(int(1.164f * Y2 + 2.017f * U), 0, 255));
+      u8 B2 = static_cast<u8>(std::clamp(int(1.164f * Y2 + 2.017f * U), 0, 255));
 
       u32 rgba = 0xff000000 | B1 << 16 | G1 << 8 | R1;
       std::memcpy(dst_ptr, &rgba, sizeof(rgba));

Source/Core/VideoCommon/TextureDecoder_x64.cpp

@@ -9,7 +9,6 @@
 #include "Common/CPUDetect.h"
 #include "Common/CommonTypes.h"
 #include "Common/Intrinsics.h"
-#include "Common/MathUtil.h"
 #include "Common/MsgHandler.h"
 #include "Common/Swap.h"
 

Source/UnitTests/Common/MathUtilTest.cpp

@@ -6,18 +6,6 @@
 
 #include "Common/MathUtil.h"
 
-TEST(MathUtil, Clamp)
-{
-  EXPECT_EQ(1, MathUtil::Clamp(1, 0, 2));
-  EXPECT_EQ(1.0, MathUtil::Clamp(1.0, 0.0, 2.0));
-
-  EXPECT_EQ(2, MathUtil::Clamp(4, 0, 2));
-  EXPECT_EQ(2.0, MathUtil::Clamp(4.0, 0.0, 2.0));
-
-  EXPECT_EQ(0, MathUtil::Clamp(-1, 0, 2));
-  EXPECT_EQ(0.0, MathUtil::Clamp(-1.0, 0.0, 2.0));
-}
-
 TEST(MathUtil, IntLog2)
 {
   EXPECT_EQ(0, IntLog2(1));