fix test compilation

Author: EmilDohne

PhotoshopAPI/src/Core/Geometry/BoundingBox.h

@@ -6,6 +6,7 @@
 #include "Point.h"
 
 #include <array>
+#include <optional>
 
 PSAPI_NAMESPACE_BEGIN
 

PhotoshopAPI/src/Core/Geometry/GeometryInstantiations.cpp

@@ -4,11 +4,14 @@
 
 PSAPI_NAMESPACE_BEGIN
 
+namespace Geometry
+{
 
-template struct Face<double, 4>;
-template struct OctreeNode<double, 128>;
-template class Octree<double, 128>;
-template struct QuadMesh<double>;
+	template struct Face<double, 4>;
+	template struct OctreeNode<double, 128>;
+	template class Octree<double, 128>;
+	template struct QuadMesh<double>;
 
+}
 
 PSAPI_NAMESPACE_END

PhotoshopAPI/src/Core/Geometry/Mesh.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include "Macros.h"
+#include "Util/Logger.h"
+#include "Util/Profiling/Perf/Instrumentor.h"
 
 #include <vector>
 #include <memory>
@@ -11,13 +13,7 @@
 
 #include <Eigen/Dense>
 
-// If we compile with C++<20 we replace the stdlib implementation with the compatibility
-// library
-#if (__cplusplus < 202002L)
-#include "tcb_span.hpp"
-#else
 #include <span>
-#endif
 
 
 PSAPI_NAMESPACE_BEGIN
@@ -91,12 +87,6 @@ namespace Geometry
             return m_VertexIndices.size();
         }
 
-        constexpr size_t vertex_idx_checked(size_t in_face_idx) const
-        {
-            static_assert(in_face_idx > _Size - 1, "Index out of bounds");
-            return m_VertexIndices[in_face_idx];
-        }
-
         void vertex_indices(std::array<size_t, _Size> vertex_indices)
         {
             m_VertexIndices = vertex_indices;

PhotoshopAPI/src/Core/Geometry/MeshOperations.h

@@ -5,6 +5,7 @@
 #include <vector>
 #include <memory>
 #include <cmath>
+#include <execution>
 
 #include "Point.h"
 #include "BoundingBox.h"

PhotoshopAPI/src/Core/Geometry/Point.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Macros.h"
+#include "Util/Logger.h"
 
 #include <vector>
 #include <array>
@@ -9,13 +10,7 @@
 #include <cassert>
 #include <algorithm>
 
-// If we compile with C++<20 we replace the stdlib implementation with the compatibility
-// library
-#if (__cplusplus < 202002L)
-#include "tcb_span.hpp"
-#else
 #include <span>
-#endif
 
 PSAPI_NAMESPACE_BEGIN
 
@@ -135,6 +130,14 @@ namespace Geometry
             return std::hash<T>()(x) ^ (std::hash<T>()(y) << 1); // XOR combined with left shift for distribution
         }
 
+		// Provide a get<I> function for structured bindings
+		template <std::size_t I>
+		constexpr auto get(Point2D<T>& point)
+		{
+			if constexpr (I == 0) return point.x;
+			else if constexpr (I == 1) return point.y;
+		}
+
         // Provide a get<I> function for structured bindings
         template <std::size_t I>
         constexpr auto& get(Point2D<T>& point) 

PhotoshopAPI/src/Core/Render/ImageBuffer.h

@@ -7,15 +7,8 @@
 #include <cstdint>
 #include <algorithm>
 #include <type_traits>
-
-
-// If we compile with C++<20 we replace the stdlib implementation with the compatibility
-// library
-#if (__cplusplus < 202002L)
-#include "tcb_span.hpp"
-#else
+#include <filesystem>
 #include <span>
-#endif
 
 #include "Core/Geometry/Point.h"
 #include "Core/Geometry/BoundingBox.h"
@@ -238,15 +231,15 @@ namespace Render
                     // coordinate space of the original buffer rather than in our rescaled
                     // buffer
                     _Precision v = static_cast<_Precision>(y) / height;
-                    _Precision orig_y = (v * this->height) - .5;
+                    _Precision orig_y = static_cast<_Precision>((v * this->height) - .5);
                     std::int64_t orig_y_int = static_cast<std::int64_t>(orig_y);
                     _Precision orig_y_fract = orig_y - std::floor(orig_y);
 
                     std::array<T, 2 * 2> matrix;
                     for (size_t x = 0; x < width; ++x)
                     {
                         _Precision u = static_cast<_Precision>(x) / width;
-                        _Precision orig_x = (u * this->width) - .5;
+                        _Precision orig_x = static_cast<_Precision>((u * this->width) - .5);
                         std::int64_t orig_x_int = static_cast<std::int64_t>(orig_x);
                         _Precision orig_x_fract = orig_x - std::floor(orig_x);
 
@@ -297,7 +290,7 @@ namespace Render
             std::for_each(horizontal_iter.begin(), horizontal_iter.end(), [&](size_t x)
                 {
                     _Precision u = static_cast<_Precision>(x) / width;
-                    _Precision orig_x = (u * this->width) - .5;
+                    _Precision orig_x = static_cast<_Precision>((u * this->width) - .5);
                     orig_x_int[x] = static_cast<std::int64_t>(orig_x);
                     orig_x_fract[x] = orig_x - std::floor(orig_x);
                 });
@@ -308,7 +301,7 @@ namespace Render
                     // coordinate space of the original buffer rather than in our rescaled
                     // buffer
                     _Precision v = static_cast<_Precision>(y) / height;
-                    _Precision orig_y = (v * this->height) - .5;
+                    _Precision orig_y = static_cast<_Precision>((v * this->height) - .5);
                     std::int64_t orig_y_int = static_cast<std::int64_t>(orig_y);
                     _Precision orig_y_fract = orig_y - std::floor(orig_y);
 
@@ -371,7 +364,7 @@ namespace Render
                 {
                     auto sample_point_or_black = [&](int64_t x, int64_t y)
                         {
-                            if (x < 0 || y < 0 || x > this->width - 1 || y > this->height - 1) [[unlikely]]
+                            if (x < 0 || y < 0 || x > static_cast<int64_t>(this->width) - 1 || y > static_cast<int64_t>(this->height) - 1) [[unlikely]]
                             {
                                 return static_cast<T>(0);
                             }
@@ -386,8 +379,8 @@ namespace Render
                     int64_t y1 = y0 + 1;
 
                     // Calculate weights
-                    U dx = point.x - static_cast<U>(x0);
-                    U dy = point.y - static_cast<U>(y0);
+                    float dx = static_cast<float>(point.x) - x0;
+                    float dy = static_cast<float>(point.y) - y0;
 
                     // Sample four surrounding pixels getting a black pixel instead of 
                     float v00 = sample_point_or_black(x0, y0);

PhotoshopAPI/src/Core/Render/Interleave.h

@@ -2,6 +2,7 @@
 
 #include "Macros.h"
 #include "Util/Logger.h"
+#include "Util/Profiling/Perf/Instrumentor.h"
 
 #include <vector>
 #include <algorithm>

PhotoshopAPI/src/Core/Render/Render.h

@@ -14,21 +14,15 @@ Support for this is still experimental and primarily for debug purposes
 #include <cmath>
 #include <algorithm>
 #include <tuple>
+#include <set>
+#include <span>
 
 #include "ImageBuffer.h"
 
 #include "Core/Geometry/Point.h"
 #include "Core/Geometry/Mesh.h"
 #include "Core/Geometry/BezierSurface.h"
 
-// If we compile with C++<20 we replace the stdlib implementation with the compatibility
-// library
-#if (__cplusplus < 202002L)
-#include "tcb_span.hpp"
-#else
-#include <span>
-#endif
-
 #include <OpenImageIO/imagebuf.h>
 #include <OpenImageIO/imagebufalgo.h>
 

PhotoshopAPI/src/Core/Warp/SmartObjectWarp.h

@@ -102,10 +102,10 @@ namespace SmartObject
 			auto bbox = warp_mesh.bbox();
 			bbox.pad(static_cast<double>(supersample_resolution));
 
-			size_t min_y = static_cast<size_t>(std::max<double>(std::round(bbox.minimum.y), 0));
-			size_t max_y = static_cast<size_t>(std::min<double>(std::round(bbox.maximum.y), buffer.height - 1));
-			size_t min_x = static_cast<size_t>(std::max<double>(std::round(bbox.minimum.x), 0));
-			size_t max_x = static_cast<size_t>(std::min<double>(std::round(bbox.maximum.x), buffer.width - 1));
+			size_t min_y = static_cast<size_t>(std::max<double>(std::round(bbox.minimum.y), static_cast<double>(0)));
+			size_t max_y = static_cast<size_t>(std::min<double>(std::round(bbox.maximum.y), static_cast<double>(buffer.height - 1)));
+			size_t min_x = static_cast<size_t>(std::max<double>(std::round(bbox.minimum.x), static_cast<double>(0)));
+			size_t max_x = static_cast<size_t>(std::min<double>(std::round(bbox.maximum.x), static_cast<double>(buffer.width - 1)));
 
 			auto vertical_iter = std::views::iota(min_y, max_y);
 			std::for_each(std::execution::par_unseq, vertical_iter.begin(), vertical_iter.end(), [&](const size_t y)