Move PupuID helpers to OpenVIII and disable viewports on non-MSVC

.github/workflows/build.ps1

@@ -114,7 +114,7 @@ vcpkg integrate install
 
 # Start the build
 cmake --preset "${env:_RELEASE_CONFIGURATION_PRESET}"
-cmake --build --preset "${env:_RELEASE_CONFIGURATION_PRESET}"
+cmake --build --preset "${env:_RELEASE_CONFIGURATION_PRESET}" --verbose
 
 # Start the packaging
 7z a ".\.dist\${env:_RELEASE_NAME}-${env:_RELEASE_VERSION}.zip" ".\$releasePath\bin\${env:_RELEASE_CONFIGURATION_RAW}\*"

.github/workflows/main-1.0.0.yaml

@@ -257,7 +257,7 @@ jobs:
 
 
   windows-build:
-    runs-on: windows-latest
+    runs-on: windows-2022
     needs: [prepare, linux-build]
     env:
       _RELEASE_CONFIGURATION_PRESET: Release-windows  # override for Windows

CMakeLists.txt

@@ -5,6 +5,12 @@ cmake_policy(SET CMP0042 NEW)
 cmake_policy(SET CMP0074 NEW)
 cmake_policy(SET CMP0091 NEW)
 
+if(MSVC)
+    set(CMAKE_GENERATOR_TOOLSET "preview")
+    message(WARNING "MSVC_VERSION=${MSVC_VERSION}")
+    message(WARNING "MSVC_TOOLSET_VERSION=${MSVC_TOOLSET_VERSION}")
+endif()
+
 set(VCPKG_DISABLE_COMPILER_TRACKING 1)
 set(VCPKG_INSTALL_OPTIONS "--clean-after-build")
 set(X_VCPKG_APPLOCAL_DEPS_INSTALL ON)

src/opengl/experimental/CMakeLists.txt

@@ -30,7 +30,6 @@ add_executable(
   ff8/SimilarAdjustments.cpp
   ff8/Configuration.cpp
   ff8/MenuSaveToggles.hpp
-  ff8/PupuID.hpp
   ImGuiDisabled.cpp
   ImGuiPushItemWidth.cpp
   ImGuiPushID.cpp
@@ -47,7 +46,6 @@ add_executable(
   test/TestBatchRenderingTexture2DDynamic.cpp
   test/TestMenu.cpp
   test/TestTexture2D.cpp
-  ff8/UniquifyPupu.hpp
   Window.cpp)
 target_link_libraries(
   ${PROJECT_NAME}_EXPERIMENTAL

src/opengl/experimental/ff8/Map.hpp

@@ -21,7 +21,6 @@
 #include "MouseToTilePos.h"
 #include "OrthographicCameraController.hpp"
 #include "SimilarAdjustments.hpp"
-#include "tile_operations.hpp"
 #include "TransformedSortedUniqueCopy.hpp"
 #include "UniqueTileValues.hpp"
 #include "Window.hpp"
@@ -37,6 +36,7 @@
 #include <glengine/GenericCombo.hpp>
 #include <glengine/OrthographicCamera.hpp>
 #include <glengine/PixelBuffer.hpp>
+#include <open_viii/graphics/background/TileOperations.hpp>
 #include <source_location>
 #include <type_traits>
 namespace ff_8
@@ -67,43 +67,74 @@ class [[nodiscard]] MoveTiles
           using TileT
             = std::ranges::range_value_t<std::remove_cvref_t<decltype(tiles)>>;
           std::vector<std::function<TileT(const TileT &)>> operations{};
-          if constexpr (std::is_same_v<
-                          typename TileFunctions::X,
-                          tile_operations::X>)
+          if constexpr (
+            std::is_same_v<
+              typename TileFunctions::X,
+              open_viii::graphics::background::tile_operations::X>)
           {
                operations.push_back(
-                 tile_operations::TranslateWithX{ m_released.x, m_pressed.x });
+                 open_viii::graphics::background::tile_operations::
+                   TranslateWithX<TileT>{
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::XT<TileT>>(m_released.x),
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::XT<TileT>>(m_pressed.x) });
           }
-          if constexpr (std::is_same_v<
-                          typename TileFunctions::Y,
-                          tile_operations::Y>)
+          if constexpr (
+            std::is_same_v<
+              typename TileFunctions::Y,
+              open_viii::graphics::background::tile_operations::Y>)
           {
                operations.push_back(
-                 tile_operations::TranslateWithY{ m_released.y, m_pressed.y });
+                 open_viii::graphics::background::tile_operations::
+                   TranslateWithY<TileT>{
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::YT<TileT>>(m_released.y),
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::YT<TileT>>(m_pressed.y) });
           }
-          if constexpr (std::is_same_v<
-                          typename TileFunctions::X,
-                          tile_operations::SourceX>)
+          if constexpr (
+            std::is_same_v<
+              typename TileFunctions::X,
+              open_viii::graphics::background::tile_operations::SourceX>)
           {
                operations.push_back(
-                 tile_operations::TranslateWithSourceX{ m_released.x,
-                                                        m_pressed.x });
+                 open_viii::graphics::background::tile_operations::
+                   TranslateWithSourceX<TileT>{
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::SourceXT<TileT>>(
+                       m_released.x),
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::SourceXT<TileT>>(
+                       m_pressed.x) });
           }
-          if constexpr (std::is_same_v<
-                          typename TileFunctions::Y,
-                          tile_operations::SourceY>)
+          if constexpr (
+            std::is_same_v<
+              typename TileFunctions::Y,
+              open_viii::graphics::background::tile_operations::SourceY>)
           {
                operations.push_back(
-                 tile_operations::TranslateWithSourceY{ m_released.y,
-                                                        m_pressed.y });
+                 open_viii::graphics::background::tile_operations::
+                   TranslateWithSourceY<TileT>{
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::SourceYT<TileT>>(
+                       m_released.y),
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::SourceYT<TileT>>(
+                       m_pressed.y) });
           }
 
-          if constexpr (std::is_same_v<
-                          typename TileFunctions::TexturePage,
-                          tile_operations::TextureId>)
+          if constexpr (
+            std::is_same_v<
+              typename TileFunctions::TexturePage,
+              open_viii::graphics::background::tile_operations::TextureId>)
           {
                operations.push_back(
-                 tile_operations::WithTextureId{ m_released.z });
+                 open_viii::graphics::background::tile_operations::
+                   WithTextureId<TileT>{
+                     static_cast<open_viii::graphics::background::
+                                   tile_operations::TextureIdT<TileT>>(
+                       m_released.z) });
           }
           GetMapHistory()->copy_working_perform_operation<TileT>(
             m_indexes,
@@ -148,9 +179,9 @@ class Map
                const auto stem = std::filesystem::path(GetMapHistory().path)
                                    .parent_path()
                                    .stem();
-               m_swizzle_path = (std::filesystem::path(m_swizzle_path)
-                                 / stem.string().substr(0, 2) / stem)
-                                  .string();
+               m_swizzle_path  = (std::filesystem::path(m_swizzle_path)
+                                  / stem.string().substr(0, 2) / stem)
+                                   .string();
                spdlog::debug(
                  "Swizzle Location: \"{}\"", m_swizzle_path.string());
           }
@@ -342,11 +373,11 @@ class Map
                           .c_str());
 
                       tile_button_state = &m_tile_button_state_hover;
-                      if (visit_unsorted_unfiltered_tiles(
-                            common_operation,
-                            MouseTileOverlap<
-                              TileFunctions,
-                              decltype(m_filters)>(tp, m_filters)))
+                      if (
+                        visit_unsorted_unfiltered_tiles(
+                          common_operation,
+                          MouseTileOverlap<TileFunctions, decltype(m_filters)>(
+                            tp, m_filters)))
                       {
                            GetWindow().trigger_refresh_image();
                            // m_changed();
@@ -403,8 +434,9 @@ class Map
                       tile_button_state = &m_tile_button_state;
                       last_pos          = ImGui::GetCursorPos();
                       text_width        = ImGui::GetItemRectMax().x;
-                      if (visit_unsorted_unfiltered_tiles(
-                            common_operation, m_filters))
+                      if (
+                        visit_unsorted_unfiltered_tiles(
+                          common_operation, m_filters))
                       {
                            GetWindow().trigger_refresh_image();
                            // m_changed();
@@ -750,7 +782,7 @@ class Map
             = glm::vec2{ texture.width(), texture.height() };
           const float tile_scale = static_cast<float>(texture.height())
                                    / static_cast<float>(GetMim()->get_height());
-          const float tile_size = tile_scale * map_dims_statics::TileSize;
+          const float tile_size  = tile_scale * map_dims_statics::TileSize;
           // glm::vec2(m_mim.get_width(tile.depth()), m_mim.get_height());
           return GetMapHistory()->get_original_version_of_working_tile(
             tile,
@@ -794,7 +826,8 @@ class Map
             {
                  auto f_tiles
                    = tiles
-                     | std::views::filter(tile_operations::NotInvalidTile{})
+                     | std::views::filter(
+                       open_viii::graphics::background::NotInvalidTile{})
                      | std::views::filter(
                        []([[maybe_unused]] const auto &tile) -> bool
                        {
@@ -814,7 +847,7 @@ class Map
                       std::ranges::transform(
                         f_tiles,
                         std::back_inserter(unique_z),
-                        tile_operations::Z{});
+                        open_viii::graphics::background::tile_operations::Z{});
                       std::ranges::sort(unique_z);
                       auto [begin, end] = std::ranges::unique(unique_z);
                       unique_z.erase(begin, end);
@@ -825,7 +858,9 @@ class Map
                  {
                       auto f_tiles_reverse_filter_z
                         = f_tiles | std::views::reverse
-                          | std::views::filter(tile_operations::ZMatch{ z });
+                          | std::views::filter(
+                            open_viii::graphics::background::tile_operations::
+                              ZMatch{ z });
                       for (const auto &tile : f_tiles_reverse_filter_z)
                       {
                            if (!lambda(tile))
@@ -1060,7 +1095,8 @@ class Map
             {
                  auto f_tiles
                    = tiles
-                     | std::views::filter(tile_operations::NotInvalidTile{});
+                     | std::views::filter(
+                       open_viii::graphics::background::NotInvalidTile{});
                  return static_cast<std::size_t>(std::ranges::count_if(
                    f_tiles, [](auto &&) { return true; }));
             });
@@ -1074,7 +1110,8 @@ class Map
             {
                  auto f_tiles
                    = tiles
-                     | std::views::filter(tile_operations::NotInvalidTile{})
+                     | std::views::filter(
+                       open_viii::graphics::background::NotInvalidTile{})
                      | std::views::filter(filter);
                  bool       changed     = false;
                  VisitState visit_state = {};

src/opengl/experimental/ff8/MapDeswizzle.hpp

@@ -5,16 +5,17 @@
 #ifndef FIELD_MAP_EDITOR_MAPDESWIZZLE_HPP
 #define FIELD_MAP_EDITOR_MAPDESWIZZLE_HPP
 #include "Map.hpp"
-#include "tile_operations.hpp"
+#include <open_viii/graphics/background/TileOperations.hpp>
 namespace ff_8
 {
 struct TileFunctionsDeswizzle
 {
-     using X              = tile_operations::X;
-     using Y              = tile_operations::Y;
-     using TexturePage    = tile_operations::TextureIdDefaultValue;
-     using UseTexturePage = std::true_type;
-     using UseBlending    = std::true_type;
+     using X           = open_viii::graphics::background::tile_operations::X;
+     using Y           = open_viii::graphics::background::tile_operations::Y;
+     using TexturePage = open_viii::graphics::background::tile_operations::
+       TextureIdDefaultValue;
+     using UseTexturePage                     = std::true_type;
+     using UseBlending                        = std::true_type;
      static constexpr const char *const label = "Map (Deswizzle)";
 };
 using MapDeswizzle = Map<TileFunctionsDeswizzle>;

src/opengl/experimental/ff8/MapDims.hpp

@@ -4,8 +4,8 @@
 
 #ifndef FIELD_MAP_EDITOR_MAPDIMS_HPP
 #define FIELD_MAP_EDITOR_MAPDIMS_HPP
-#include "tile_operations.hpp"
 #include <glm/glm.hpp>
+#include <open_viii/graphics/background/TileOperations.hpp>
 namespace ff_8
 {
 namespace map_dims_statics
@@ -52,9 +52,10 @@ class MapDims
             [&](const auto &tiles)
             {
                  {
-                      auto f_tiles = tiles
-                                     | std::views::filter(
-                                       tile_operations::NotInvalidTile{});
+                      auto f_tiles
+                        = tiles
+                          | std::views::filter(
+                            open_viii::graphics::background::NotInvalidTile{});
                       get_x(f_tiles);
                       get_y(f_tiles);
                       get_true_x(f_tiles);
@@ -121,7 +122,8 @@ class MapDims
      template<std::ranges::range TilesR>
      void get_true_x(TilesR &&f_tiles)
      {
-          static constexpr tile_operations::X true_x = {};
+          static constexpr open_viii::graphics::background::tile_operations::X
+            true_x = {};
           const auto [true_i_min_x, true_i_max_x]
             = std::ranges::minmax_element(f_tiles, {}, true_x);
           if (true_i_min_x == true_i_max_x)
@@ -134,7 +136,8 @@ class MapDims
      template<std::ranges::range TilesR>
      void get_true_y(TilesR &&f_tiles)
      {
-          static constexpr tile_operations::Y true_y = {};
+          static constexpr open_viii::graphics::background::tile_operations::Y
+            true_y = {};
           const auto [true_i_min_y, true_i_max_y]
             = std::ranges::minmax_element(f_tiles, {}, true_y);
           if (true_i_min_y == true_i_max_y)

src/opengl/experimental/ff8/MapFilters.hpp

@@ -127,11 +127,12 @@ class MapFilters
                                    {
                                         const auto push_id_1
                                           = glengine::ImGuiPushId();
-                                        if (ImGui::Selectable(
-                                              string.c_str(),
-                                              static_cast<bool>(*boolptr),
-                                              0,
-                                              size))
+                                        if (
+                                          ImGui::Selectable(
+                                            string.c_str(),
+                                            static_cast<bool>(*boolptr),
+                                            0,
+                                            size))
                                         {
                                              *boolptr
                                                = !static_cast<bool>(*boolptr);
@@ -247,7 +248,8 @@ class MapFilters
           }
           return ret_changed;
      }
-     bool operator()(const PupuID &pupu_id) const
+     bool
+       operator()(const open_viii::graphics::background::PupuID &pupu_id) const
      {
           return filter(
             // todo get pupu ID from map history? Map filters currently has no

src/opengl/experimental/ff8/MapHistory.cpp

@@ -61,13 +61,14 @@ namespace ff_8
 }
 
 
-std::vector<PupuID> MapHistory::calculate_pupu(const map_t &map)
+std::vector<open_viii::graphics::background::PupuID>
+  MapHistory::calculate_pupu(const map_t &map)
 {
      return map.visit_tiles(
        [](const auto &tiles)
        {
-            std::vector<PupuID> pupu_ids = {};
-            UniquifyPupu        pupu_map = {};
+            std::vector<open_viii::graphics::background::PupuID> pupu_ids = {};
+            open_viii::graphics::background::UniquifyPupu        pupu_map = {};
             pupu_ids.reserve(std::ranges::size(tiles));
             std::ranges::transform(
               tiles, std::back_insert_iterator(pupu_ids), pupu_map);
@@ -81,7 +82,8 @@ MapHistory::MapHistory(map_t map)
   , m_front_pupu(calculate_pupu(m_front))
 {
 }
-[[nodiscard]] const std::vector<PupuID> &MapHistory::pupu() const noexcept
+[[nodiscard]] const std::vector<open_viii::graphics::background::PupuID> &
+  MapHistory::pupu() const noexcept
 {
      return m_front_pupu;
 }