[Base/GPU] Cleanup float comparisons and NaN and -0 in clamping

C++ relational operators are supposed to raise FE_INVALID if an argument is
NaN, use std::isless/greater[equal] instead where they were easy to locate
(though there are other places possibly, mostly min/max and clamp usage was
checked).

Also fixes a copy-paste error making the CPU shader interpreter execute
MINs as MAXs instead.

Author: Triang3l

src/xenia/apu/xma_context.cc

@@ -921,7 +921,7 @@ void XmaContext::ConvertFrame(const uint8_t** samples, bool is_two_channel,
       auto in = reinterpret_cast<const float*>(samples[j]);
 
       // Raw samples sometimes aren't within [-1, 1]
-      float scaled_sample = xe::saturate_signed(in[i]) * scale;
+      float scaled_sample = xe::clamp_float(in[i], -1.0f, 1.0f) * scale;
 
       // Convert the sample and output it in big endian.
       auto sample = static_cast<int16_t>(scaled_sample);

src/xenia/base/math.h

@@ -60,20 +60,22 @@ constexpr T round_up(T value, V multiple, bool force_non_zero = true) {
   return (value + multiple - 1) / multiple * multiple;
 }
 
-// Using the same conventions as in shading languages, returning 0 for NaN.
-// std::max is `a < b ? b : a`, thus in case of NaN, the first argument is
-// always returned. Also -0 is not < +0, so +0 is also chosen for it.
+// For NaN, returns min_value (or, if it's NaN too, max_value).
+// If either of the boundaries is zero, and if the value is at that boundary or
+// exceeds it, the result will have the sign of that boundary. If both
+// boundaries are zero, which sign is selected among the argument signs is not
+// explicitly defined.
 template <typename T>
-constexpr T saturate_unsigned(T value) {
-  return std::min(static_cast<T>(1.0f), std::max(static_cast<T>(0.0f), value));
+T clamp_float(T value, T min_value, T max_value) {
+  float clamped_to_min = std::isgreater(value, min_value) ? value : min_value;
+  return std::isless(clamped_to_min, max_value) ? clamped_to_min : max_value;
 }
 
-// This diverges from the GPU NaN rules for signed normalized formats (NaN
-// should be converted to 0, not to -1), but this expectation is not needed most
-// of time, and cannot be met for free (unlike for 0...1 clamping).
+// Using the same conventions as in shading languages, returning 0 for NaN.
+// 0 is always returned as positive.
 template <typename T>
-constexpr T saturate_signed(T value) {
-  return std::min(static_cast<T>(1.0f), std::max(static_cast<T>(-1.0f), value));
+T saturate(T value) {
+  return clamp_float(value, static_cast<T>(0.0f), static_cast<T>(1.0f));
 }
 
 // Gets the next power of two value that is greater than or equal to the given
@@ -330,12 +332,6 @@ inline uint64_t rotate_left(uint64_t v, uint8_t sh) {
 }
 #endif  // XE_PLATFORM_WIN32
 
-template <typename T>
-T clamp(T value, T min_value, T max_value) {
-  const T t = value < min_value ? min_value : value;
-  return t > max_value ? max_value : t;
-}
-
 #if XE_ARCH_AMD64
 // Utilities for SSE values.
 template <int N>

src/xenia/debug/ui/debug_window.cc

@@ -182,7 +182,7 @@ void DebugWindow::DrawFrame(ImGuiIO& io) {
                          ImVec2(kSplitterWidth, top_panes_height));
   if (ImGui::IsItemActive()) {
     function_pane_width += io.MouseDelta.x;
-    function_pane_width = xe::clamp(function_pane_width, 30.0f, FLT_MAX);
+    function_pane_width = xe::clamp_float(function_pane_width, 30.0f, FLT_MAX);
   }
   ImGui::SameLine();
   ImGui::BeginChild("##source_pane",
@@ -194,7 +194,7 @@ void DebugWindow::DrawFrame(ImGuiIO& io) {
                          ImVec2(kSplitterWidth, top_panes_height));
   if (ImGui::IsItemActive()) {
     source_pane_width += io.MouseDelta.x;
-    source_pane_width = xe::clamp(source_pane_width, 30.0f, FLT_MAX);
+    source_pane_width = xe::clamp_float(source_pane_width, 30.0f, FLT_MAX);
   }
   ImGui::SameLine();
   ImGui::BeginChild("##registers_pane",
@@ -206,7 +206,8 @@ void DebugWindow::DrawFrame(ImGuiIO& io) {
                          ImVec2(kSplitterWidth, top_panes_height));
   if (ImGui::IsItemActive()) {
     registers_pane_width += io.MouseDelta.x;
-    registers_pane_width = xe::clamp(registers_pane_width, 30.0f, FLT_MAX);
+    registers_pane_width =
+        xe::clamp_float(registers_pane_width, 30.0f, FLT_MAX);
   }
   ImGui::SameLine();
   ImGui::BeginChild("##right_pane", ImVec2(0, top_panes_height), true);
@@ -234,7 +235,7 @@ void DebugWindow::DrawFrame(ImGuiIO& io) {
   ImGui::InvisibleButton("##hsplitter0", ImVec2(-1, kSplitterWidth));
   if (ImGui::IsItemActive()) {
     bottom_panes_height -= io.MouseDelta.y;
-    bottom_panes_height = xe::clamp(bottom_panes_height, 30.0f, FLT_MAX);
+    bottom_panes_height = xe::clamp_float(bottom_panes_height, 30.0f, FLT_MAX);
   }
   ImGui::BeginChild("##log_pane", ImVec2(log_pane_width, bottom_panes_height),
                     true);
@@ -245,7 +246,8 @@ void DebugWindow::DrawFrame(ImGuiIO& io) {
                          ImVec2(kSplitterWidth, bottom_panes_height));
   if (ImGui::IsItemActive()) {
     breakpoints_pane_width -= io.MouseDelta.x;
-    breakpoints_pane_width = xe::clamp(breakpoints_pane_width, 30.0f, FLT_MAX);
+    breakpoints_pane_width =
+        xe::clamp_float(breakpoints_pane_width, 30.0f, FLT_MAX);
   }
   ImGui::SameLine();
   ImGui::BeginChild("##breakpoints_pane", ImVec2(0, 0), true);

src/xenia/gpu/draw_util.cc

@@ -399,16 +399,11 @@ void GetHostViewportInfo(const RegisterFile& regs,
       float offset_axis = offset_base_xy[i] + offset_add_xy[i];
       float scale_axis = scale_xy[i];
       float scale_axis_abs = std::abs(scale_xy[i]);
-      float axis_0 = offset_axis - scale_axis_abs;
-      float axis_1 = offset_axis + scale_axis_abs;
       float axis_max_unscaled_float = float(xy_max_unscaled[i]);
-      // max(0.0f, xy) drops NaN and < 0 - max picks the first argument in the
-      // !(a < b) case (always for NaN), min as float (axis_max_unscaled_float
-      // is well below 2^24) to safely drop very large values.
-      uint32_t axis_0_int =
-          uint32_t(std::min(axis_max_unscaled_float, std::max(0.0f, axis_0)));
-      uint32_t axis_1_int =
-          uint32_t(std::min(axis_max_unscaled_float, std::max(0.0f, axis_1)));
+      uint32_t axis_0_int = uint32_t(xe::clamp_float(
+          offset_axis - scale_axis_abs, 0.0f, axis_max_unscaled_float));
+      uint32_t axis_1_int = uint32_t(xe::clamp_float(
+          offset_axis + scale_axis_abs, 0.0f, axis_max_unscaled_float));
       uint32_t axis_extent_int = axis_1_int - axis_0_int;
       viewport_info_out.xy_offset[i] = axis_0_int * axis_resolution_scale;
       viewport_info_out.xy_extent[i] = axis_extent_int * axis_resolution_scale;
@@ -511,8 +506,8 @@ void GetHostViewportInfo(const RegisterFile& regs,
       // extension. But cases when this really matters are yet to be found -
       // trying to fix this will result in more correct depth values, but
       // incorrect clipping.
-      z_min = xe::saturate_unsigned(host_clip_offset_z);
-      z_max = xe::saturate_unsigned(host_clip_offset_z + host_clip_scale_z);
+      z_min = xe::saturate(host_clip_offset_z);
+      z_max = xe::saturate(host_clip_offset_z + host_clip_scale_z);
       // Direct3D 12 doesn't allow reverse depth range - on some drivers it
       // works, on some drivers it doesn't, actually, but it was never
       // explicitly allowed by the specification.
@@ -877,10 +872,10 @@ bool GetResolveInfo(const RegisterFile& regs, const Memory& memory,
   GetScissor(regs, scissor, false);
   int32_t scissor_right = int32_t(scissor.offset[0] + scissor.extent[0]);
   int32_t scissor_bottom = int32_t(scissor.offset[1] + scissor.extent[1]);
-  x0 = xe::clamp(x0, int32_t(scissor.offset[0]), scissor_right);
-  y0 = xe::clamp(y0, int32_t(scissor.offset[1]), scissor_bottom);
-  x1 = xe::clamp(x1, int32_t(scissor.offset[0]), scissor_right);
-  y1 = xe::clamp(y1, int32_t(scissor.offset[1]), scissor_bottom);
+  x0 = std::clamp(x0, int32_t(scissor.offset[0]), scissor_right);
+  y0 = std::clamp(y0, int32_t(scissor.offset[1]), scissor_bottom);
+  x1 = std::clamp(x1, int32_t(scissor.offset[0]), scissor_right);
+  y1 = std::clamp(y1, int32_t(scissor.offset[1]), scissor_bottom);
 
   assert_true(x0 <= x1 && y0 <= y1);