Add ExportAsCubemap node

Author: otto-link

Hesiod/app/darkstyle.css

@@ -146,7 +146,7 @@ R""(
 	border: 1px solid #5B5B5B;
     }
 
-    QPushButton,
+    QPushButton:checked,
     QToolButton:checked
     {
 	background-color: #4772b3;
@@ -155,20 +155,20 @@ R""(
 	outline: none;
     }
 
-    QPushButton,
+    QPushButton:hover,
     QToolButton:hover
     {
 	background-color: #8B8B8B;
 	color: #DFE1E2;
     }
 
-    QPushButton,
+    QPushButton:pressed,
     QToolButton:pressed
     {
 	background-color: #ABABAB;
     }
 
-    QPushButton,
+    QPushButton:selected,
     QToolButton:selected
     {
 	background: #5B5B5B;

Hesiod/include/hesiod/model/nodes/node_factory.hpp

@@ -105,6 +105,7 @@ DECLARE_NODE(dilation)
 DECLARE_NODE(distance_transform)
 DECLARE_NODE(erosion)
 DECLARE_NODE(expand_shrink)
+DECLARE_NODE(export_as_cubemap)
 DECLARE_NODE(export_asset)
 DECLARE_NODE(export_cloud)
 DECLARE_NODE(export_heightmap)

Hesiod/src/model/nodes/node_factory.cpp

@@ -145,6 +145,7 @@ std::map<std::string, std::string> get_node_inventory()
       {"Erosion", "Operator/Morphology"},
       {"ExpandShrink", "Filter/Recast"},
       {"ExportAsset", "IO/Files"},
+      {"ExportAsCubemap", "WIP"}, // "IO/Files"},
       {"ExportCloud", "IO/Files"},
       {"ExportHeightmap", "IO/Files"},
       {"ExportNormalMap", "IO/Files"},
@@ -351,6 +352,7 @@ std::shared_ptr<gnode::Node> node_factory(const std::string           &node_type
     SETUP_NODE(Erosion, erosion);
     SETUP_NODE(ExpandShrink, expand_shrink);
     SETUP_NODE(ExportAsset, export_asset);
+    SETUP_NODE(ExportAsCubemap, export_as_cubemap);
     SETUP_NODE(ExportCloud, export_cloud);
     SETUP_NODE(ExportHeightmap, export_heightmap);
     SETUP_NODE(ExportNormalMap, export_normal_map);

Hesiod/src/model/nodes/nodes_function/export_as_cubemap.cpp

@@ -0,0 +1,74 @@
+/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
+ * Public License. The full license is in the file LICENSE, distributed with
+ * this software. */
+
+#include "highmap/export.hpp"
+
+#include "attributes.hpp"
+
+#include "hesiod/logger.hpp"
+#include "hesiod/model/enum_mapping.hpp"
+#include "hesiod/model/nodes/base_node.hpp"
+#include "hesiod/model/utils.hpp"
+
+using namespace attr;
+
+namespace hesiod
+{
+
+void setup_export_as_cubemap_node(BaseNode *p_node)
+{
+  LOG->trace("setup node {}", p_node->get_label());
+
+  // port(s)
+  p_node->add_port<hmap::Heightmap>(gnode::PortType::IN, "input");
+
+  // attribute(s)
+  ADD_ATTR(FilenameAttribute,
+           "fname",
+           std::filesystem::path("cubemap.png"),
+           "PNG (*.png)",
+           true);
+  ADD_ATTR(IntAttribute, "cubemap_resolution", 64, 32, INT_MAX);
+  ADD_ATTR(FloatAttribute, "overlap", 0.25f, 0.1f, 5.f);
+  ADD_ATTR(IntAttribute, "ir", 16, 1, INT_MAX);
+  ADD_ATTR(BoolAttribute, "splitted", false);
+  ADD_ATTR(BoolAttribute, "auto_export", true);
+
+  // attribute(s) order
+  p_node->set_attr_ordered_key({"fname",
+                                "cubemap_resolution",
+                                "overlap",
+                                "ir",
+                                "splitted",
+                                "_SEPARATOR_",
+                                "auto_export"});
+}
+
+void compute_export_as_cubemap_node(BaseNode *p_node)
+{
+  Q_EMIT p_node->compute_started(p_node->get_id());
+
+  LOG->trace("computing node {}", p_node->get_label());
+
+  hmap::Heightmap *p_in = p_node->get_value_ref<hmap::Heightmap>("input");
+
+  if (p_in && GET("auto_export", BoolAttribute))
+  {
+    hmap::Array z = p_in->to_array();
+    std::string fname = GET("fname", FilenameAttribute).string();
+
+    hmap::export_as_cubemap(fname,
+                            z,
+                            GET("cubemap_resolution", IntAttribute),
+                            GET("overlap", FloatAttribute),
+                            GET("ir", IntAttribute),
+                            hmap::Cmap::GRAY,
+                            GET("splitted", BoolAttribute),
+                            nullptr);
+  }
+
+  Q_EMIT p_node->compute_finished(p_node->get_id());
+}
+
+} // namespace hesiod