path: root/extension/src/openvic-extension/classes/GUINode.cpp

#include "GUINode.hpp"

#include <limits>

#include <godot_cpp/classes/bit_map.hpp>
#include <godot_cpp/classes/button.hpp>
#include <godot_cpp/classes/canvas_item.hpp>
#include <godot_cpp/classes/check_box.hpp>
#include <godot_cpp/classes/control.hpp>
#include <godot_cpp/classes/image.hpp>
#include <godot_cpp/classes/label.hpp>
#include <godot_cpp/classes/node.hpp>
#include <godot_cpp/classes/object.hpp>
#include <godot_cpp/classes/panel.hpp>
#include <godot_cpp/classes/ref.hpp>
#include <godot_cpp/classes/style_box.hpp>
#include <godot_cpp/classes/style_box_texture.hpp>
#include <godot_cpp/classes/texture2d.hpp>
#include <godot_cpp/classes/texture_progress_bar.hpp>
#include <godot_cpp/classes/texture_rect.hpp>
#include <godot_cpp/core/defs.hpp>
#include <godot_cpp/core/error_macros.hpp>
#include <godot_cpp/core/object.hpp>
#include <godot_cpp/core/property_info.hpp>
#include <godot_cpp/variant/node_path.hpp>
#include <godot_cpp/variant/rect2.hpp>
#include <godot_cpp/variant/string.hpp>
#include <godot_cpp/variant/string_name.hpp>
#include <godot_cpp/variant/utility_functions.hpp>
#include <godot_cpp/variant/variant.hpp>
#include <godot_cpp/variant/vector2.hpp>
#include <godot_cpp/variant/vector2i.hpp>

#include "openvic-extension/utility/ClassBindings.hpp"
#include "openvic-extension/utility/UITools.hpp"
#include "openvic-extension/utility/Utilities.hpp"

using namespace godot;
using namespace OpenVic;

#define APPLY_TO_CHILD_TYPES(F) \
   F(Button, button) \
   F(CheckBox, check_box) \
   F(Label, label) \
   F(Panel, panel) \
   F(TextureProgressBar, progress_bar) \
   F(TextureRect, texture_rect) \
   F(GUIOverlappingElementsBox, gui_overlapping_elements_box) \
   F(GUIScrollbar, gui_scrollbar) \
   F(GUIListBox, gui_listbox)

#define APPLY_TO_TEXTURE_TYPES(F) \
   F(GFXSpriteTexture, gfx_sprite_texture) \
   F(GFXMaskedFlagTexture, gfx_masked_flag_texture) \
   F(GFXPieChartTexture, gfx_pie_chart_texture)

void GUINode::_bind_methods() {
   OV_BIND_SMETHOD(generate_gui_element, { "gui_scene", "gui_element", "name" }, DEFVAL(String {}));
   OV_BIND_METHOD(GUINode::add_gui_element, { "gui_scene", "gui_element", "name" }, DEFVAL(String {}));
   OV_BIND_SMETHOD(get_gui_position, { "gui_scene", "gui_position" });

   OV_BIND_METHOD(GUINode::get_click_mask);
   OV_BIND_METHOD(GUINode::set_click_mask, { "mask" });
   ADD_PROPERTY(
      PropertyInfo(Variant::OBJECT, "click_mask", PROPERTY_HINT_RESOURCE_TYPE, "BitMap"), "set_click_mask", "get_click_mask"
   );

   OV_BIND_METHOD(GUINode::set_click_mask_from_nodepaths, { "paths" });
   OV_BIND_METHOD(GUINode::update_click_mask);

#define GET_BINDINGS(type, name) \
   OV_BIND_SMETHOD(get_##name##_from_node, { "node" }); \
   OV_BIND_METHOD(GUINode::get_##name##_from_nodepath, { "path" });

   APPLY_TO_CHILD_TYPES(GET_BINDINGS)

   OV_BIND_SMETHOD(get_texture_from_node, { "node" });
   OV_BIND_METHOD(GUINode::get_texture_from_nodepath, { "path" });

   APPLY_TO_TEXTURE_TYPES(GET_BINDINGS)

#undef GET_BINDINGS

   OV_BIND_METHOD(GUINode::hide_node, { "path" });
   OV_BIND_METHOD(GUINode::hide_nodes, { "paths" });

   OV_BIND_SMETHOD(int_to_formatted_string, { "val" });
   OV_BIND_SMETHOD(float_to_formatted_string, { "val", "decimal_places" });
   OV_BIND_SMETHOD(format_province_name, { "province_identifier" });
}

GUINode::GUINode() {
   set_anchors_and_offsets_preset(PRESET_FULL_RECT);
   set_h_grow_direction(GROW_DIRECTION_BOTH);
   set_v_grow_direction(GROW_DIRECTION_BOTH);
   set_mouse_filter(MOUSE_FILTER_STOP);
}

Control* GUINode::generate_gui_element(String const& gui_scene, String const& gui_element, String const& name) {
   Control* result = nullptr;
   if (!UITools::generate_gui_element(gui_scene, gui_element, name, result)) {
      UtilityFunctions::push_error("Error generating GUI element ", gui_element, " from GUI scene ", gui_scene);
   }
   return result;
}

Error GUINode::add_gui_element(String const& gui_scene, String const& gui_element, String const& name) {
   Error err = OK;
   Control* result = nullptr;
   if (!UITools::generate_gui_element(gui_scene, gui_element, name, result)) {
      UtilityFunctions::push_error("Error generating GUI element ", gui_element, " from GUI scene ", gui_scene);
      err = FAILED;
   }
   if (result != nullptr) {
      add_child(result);
   }
   return err;
}

Vector2 GUINode::get_gui_position(String const& gui_scene, String const& gui_position) {
   GUI::Position const* position = UITools::get_gui_position(gui_scene, gui_position);
   ERR_FAIL_NULL_V(position, {});
   return Utilities::to_godot_fvec2(position->get_position());
}

template<std::derived_from<godot::Node> T>
static T* _cast_node(Node* node) {
   ERR_FAIL_NULL_V(node, nullptr);
   T* result = Object::cast_to<T>(node);
   ERR_FAIL_NULL_V_MSG(
      result, nullptr,
      vformat("Failed to cast node %s from type %s to %s", node->get_name(), node->get_class(), T::get_class_static())
   );
   return result;
}

#define CHILD_GET_FUNCTIONS(type, name) \
   type* GUINode::get_##name##_from_node(Node* node) { \
      return _cast_node<type>(node); \
   } \
   type* GUINode::get_##name##_from_nodepath(NodePath const& path) const { \
      return _cast_node<type>(get_node_internal(path)); \
   }

APPLY_TO_CHILD_TYPES(CHILD_GET_FUNCTIONS)

#undef CHILD_GET_FUNCTIONS

Ref<Texture2D> GUINode::get_texture_from_node(Node* node) {
   ERR_FAIL_NULL_V(node, nullptr);
   if (TextureRect const* texture_rect = Object::cast_to<TextureRect>(node); texture_rect != nullptr) {
      const Ref<Texture2D> texture = texture_rect->get_texture();
      ERR_FAIL_NULL_V_MSG(texture, nullptr, vformat("Failed to get Texture2D from TextureRect %s", node->get_name()));
      return texture;
   } else if (Button const* button = Object::cast_to<Button>(node); button != nullptr) {
      static const StringName theme_name_normal = "normal";
      const Ref<StyleBox> stylebox = button->get_theme_stylebox(theme_name_normal);
      ERR_FAIL_NULL_V_MSG(
         stylebox, nullptr, vformat("Failed to get StyleBox %s from Button %s", theme_name_normal, node->get_name())
      );
      const Ref<StyleBoxTexture> stylebox_texture = stylebox;
      ERR_FAIL_NULL_V_MSG(
         stylebox_texture, nullptr, vformat(
            "Failed to cast StyleBox %s from Button %s to type StyleBoxTexture", theme_name_normal, node->get_name()
         )
      );
      const Ref<Texture2D> result = stylebox_texture->get_texture();
      ERR_FAIL_NULL_V_MSG(
         result, nullptr,
         vformat("Failed to get Texture2D from StyleBoxTexture %s from Button %s", theme_name_normal, node->get_name())
      );
      return result;
   }
   ERR_FAIL_V_MSG(
      nullptr, vformat("Failed to cast node %s from type %s to TextureRect or Button", node->get_name(), node->get_class())
   );
}

Ref<Texture2D> GUINode::get_texture_from_nodepath(NodePath const& path) const {
   return get_texture_from_node(get_node_internal(path));
}

template<std::derived_from<Texture2D> T>
static Ref<T> _cast_texture(Ref<Texture2D> const& texture) {
   ERR_FAIL_NULL_V(texture, nullptr);
   const Ref<T> result = texture;
   ERR_FAIL_NULL_V_MSG(
      result, nullptr, vformat("Failed to cast Texture2D from type %s to %s", texture->get_class(), T::get_class_static())
   );
   return result;
}

#define TEXTURE_GET_FUNCTIONS(type, name) \
   Ref<type> GUINode::get_##name##_from_node(Node* node) { \
      return _cast_texture<type>(get_texture_from_node(node)); \
   } \
   Ref<type> GUINode::get_##name##_from_nodepath(NodePath const& path) const { \
      return _cast_texture<type>(get_texture_from_nodepath(path)); \
   }

APPLY_TO_TEXTURE_TYPES(TEXTURE_GET_FUNCTIONS)

#undef TEXTURE_GET_FUNCTIONS

#undef APPLY_TO_CHILD_TYPES

Error GUINode::hide_node(NodePath const& path) const {
   CanvasItem* node = _cast_node<CanvasItem>(get_node_internal(path));
   ERR_FAIL_NULL_V(node, FAILED);
   node->hide();
   return OK;
}

Error GUINode::hide_nodes(TypedArray<NodePath> const& paths) const {
   Error ret = OK;
   for (int32_t i = 0; i < paths.size(); ++i) {
      if (hide_node(paths[i]) != OK) {
         ret = FAILED;
      }
   }
   return ret;
}

String GUINode::int_to_formatted_string(int64_t val) {
   return Utilities::int_to_formatted_string(val);
}

String GUINode::float_to_formatted_string(float val, int32_t decimal_places) {
   return Utilities::float_to_formatted_string(val, decimal_places);
}

String GUINode::format_province_name(String const& province_identifier) {
   static const String province_prefix = "PROV";
   return province_prefix + province_identifier;
}

Ref<BitMap> GUINode::get_click_mask() const {
   return _click_mask;
}

void GUINode::set_click_mask(Ref<BitMap> const& mask) {
   if (_click_mask == mask) {
      return;
   }
   _click_mask = mask;
   queue_redraw();
   update_minimum_size();
}

bool GUINode::_update_click_mask_for(Ref<Image> const& img, int index) {
   ERR_FAIL_INDEX_V(index, _mask_controls.size(), false);
   Control* control = _mask_controls[index];
   if (!UtilityFunctions::is_instance_valid(control) && !control->is_inside_tree()) {
      _mask_controls.remove_at(index);
      return false;
   }
   ERR_FAIL_COND_V(img.is_null(), false);
   Ref<Texture2D> texture = get_texture_from_node(control);
   ERR_FAIL_COND_V(texture.is_null(), false);
   Ref<Image> texture_img = texture->get_image();
   if (img->is_empty()) {
      img->copy_from(texture_img);
   } else {
      if (img->get_format() != texture_img->get_format()) {
         img->convert(texture_img->get_format());
      }
      Vector2i img_size = img->get_size();
      Vector2i total_size = control->get_screen_position() + texture_img->get_size();
      Vector2i new_img_size = img_size.max(total_size);
      if (new_img_size != img_size) {
         img->crop(new_img_size.x, new_img_size.y);
      }
      img->blend_rect(texture_img, texture_img->get_used_rect(), control->get_position());
   }
   ERR_FAIL_COND_V(img->is_empty(), false);
   return true;
}

void GUINode::update_click_mask() {
   static constexpr real_t max_real = std::numeric_limits<real_t>::max();
   static const Point2 max_point { max_real, max_real };
   if (_mask_controls.size() == 0) {
      return;
   }

   if (_click_mask.is_null()) {
      _click_mask.instantiate();
   }
   Ref<Image> img;
   img.instantiate();
   Vector2 size = get_size();
   img->create(size.x, size.y, false, Image::Format::FORMAT_RGBA8);
   Point2 highest_position = { max_real, max_real };
   for (int index = 0; index < _mask_controls.size(); index++) {
      if (!_update_click_mask_for(img, index)) {
         continue;
      }
      Vector2 screen_pos = _mask_controls[index]->get_screen_position();
      highest_position = highest_position.min(screen_pos);
   }
   ERR_FAIL_COND(img.is_null());
   ERR_FAIL_COND(highest_position == max_point);
   _texture_region = Rect2(Point2(), img->get_size());
   _position_rect = Rect2(highest_position, _texture_region.get_size());
   _click_mask->create_from_image_alpha(img);
   queue_redraw();
   update_minimum_size();
}

void GUINode::set_click_mask_from_nodepaths(TypedArray<NodePath> const& paths) {
   // TODO: Update to use https://github.com/godotengine/godot/pull/90916
   // for(godot::Control* control : _mask_controls) {
   //    control->set_mouse_filter(Control::MouseFilter::MOUSE_FILTER_STOP);
   // }
   _mask_controls.clear();
   for (int index = 0; index < paths.size(); index++) {
      Control* control = _cast_node<Control>(get_node_internal(paths[index]));
      ERR_CONTINUE(control == nullptr);
      control->set_mouse_filter(Control::MouseFilter::MOUSE_FILTER_IGNORE);
      _mask_controls.push_back(control);
   }
   update_click_mask();
}

bool GUINode::_has_point(godot::Vector2 const& p_point) const {
   if (!_click_mask.is_valid()) {
      return Control::_has_point(p_point);
   }

   Point2 point = p_point;
   Rect2 rect;
   Size2 mask_size = _click_mask->get_size();

   if (!_position_rect.has_area()) {
      rect.size = mask_size;
   } else {
      // we need to transform the point from our scaled / translated image back to our mask image
      Point2 ofs = _position_rect.position;
      Size2 scale = mask_size / _position_rect.size;

      // offset and scale the new point position to adjust it to the bitmask size
      point -= ofs;
      point *= scale;

      // finally, we need to check if the point is inside a rectangle with a position >= 0,0 and a size <= mask_size
      rect.position = _texture_region.position.min(Point2 {});
      rect.size = mask_size.min(_texture_region.size);
   }

   if (!rect.has_point(point)) {
      return false;
   }

   return _click_mask->get_bitv(point);
}