aboutsummaryrefslogtreecommitdiff
path: root/extension/src
diff options
context:
space:
mode:
author hop311 <hop3114@gmail.com>2024-02-19 22:05:16 +0100
committer hop311 <hop3114@gmail.com>2024-02-19 22:26:52 +0100
commitc48d14ca66d47ea7c25bb9a36c3d51f76d8351fc (patch)
tree1912fb231991b53dd638a295bb8d8f84b587885b /extension/src
parent275cfbb62fe69828aeb9968110ad822447322a4e (diff)
Added multipurpose GFXSpriteTexture + reworked GFXButtonStateTexturesprite-texture
Diffstat (limited to 'extension/src')
-rw-r--r--extension/src/openvic-extension/classes/GFXButtonStateTexture.cpp61
-rw-r--r--extension/src/openvic-extension/classes/GFXButtonStateTexture.hpp32
-rw-r--r--extension/src/openvic-extension/classes/GFXIconTexture.cpp142
-rw-r--r--extension/src/openvic-extension/classes/GFXMaskedFlagTexture.cpp58
-rw-r--r--extension/src/openvic-extension/classes/GFXMaskedFlagTexture.hpp19
-rw-r--r--extension/src/openvic-extension/classes/GFXSpriteTexture.cpp159
-rw-r--r--extension/src/openvic-extension/classes/GFXSpriteTexture.hpp (renamed from extension/src/openvic-extension/classes/GFXIconTexture.hpp)33
-rw-r--r--extension/src/openvic-extension/classes/GUINode.cpp2
-rw-r--r--extension/src/openvic-extension/classes/GUINode.hpp6
-rw-r--r--extension/src/openvic-extension/register_types.cpp5
-rw-r--r--extension/src/openvic-extension/utility/UITools.cpp74
11 files changed, 316 insertions, 275 deletions
diff --git a/extension/src/openvic-extension/classes/GFXButtonStateTexture.cpp b/extension/src/openvic-extension/classes/GFXButtonStateTexture.cpp
index e6dff1f..dcee965 100644
--- a/extension/src/openvic-extension/classes/GFXButtonStateTexture.cpp
+++ b/extension/src/openvic-extension/classes/GFXButtonStateTexture.cpp
@@ -1,5 +1,7 @@
#include "GFXButtonStateTexture.hpp"
+#include <godot_cpp/variant/utility_functions.hpp>
+
#include "openvic-extension/utility/ClassBindings.hpp"
using namespace OpenVic;
@@ -9,8 +11,6 @@ void GFXButtonStateTexture::_bind_methods() {
OV_BIND_METHOD(GFXButtonStateTexture::set_button_state, { "new_button_state" });
OV_BIND_METHOD(GFXButtonStateTexture::get_button_state);
- OV_BIND_SMETHOD(get_generate_state_image_func_name);
-
OV_BIND_SMETHOD(button_state_to_theme_name, { "button_state" });
OV_BIND_METHOD(GFXButtonStateTexture::get_button_state_theme);
@@ -24,14 +24,14 @@ void GFXButtonStateTexture::_bind_methods() {
GFXButtonStateTexture::GFXButtonStateTexture() : button_state { HOVER } {}
Ref<GFXButtonStateTexture> GFXButtonStateTexture::make_gfx_button_state_texture(
- ButtonState button_state, Ref<Image> const& source_image
+ ButtonState button_state, Ref<Image> const& source_image, Rect2i const& region
) {
Ref<GFXButtonStateTexture> button_state_texture;
button_state_texture.instantiate();
ERR_FAIL_NULL_V(button_state_texture, nullptr);
button_state_texture->set_button_state(button_state);
if (source_image.is_valid()) {
- ERR_FAIL_COND_V(button_state_texture->generate_state_image(source_image) != OK, nullptr);
+ ERR_FAIL_COND_V(button_state_texture->generate_state_image(source_image, region) != OK, nullptr);
}
return button_state_texture;
}
@@ -41,14 +41,16 @@ void GFXButtonStateTexture::set_button_state(ButtonState new_button_state) {
button_state = new_button_state;
}
-Error GFXButtonStateTexture::generate_state_image(Ref<Image> const& source_image) {
+Error GFXButtonStateTexture::generate_state_image(Ref<Image> const& source_image, Rect2i const& region) {
ERR_FAIL_COND_V(source_image.is_null() || source_image->is_empty(), FAILED);
+ const Rect2i source_image_rect { {}, source_image->get_size() };
+ ERR_FAIL_COND_V(!region.has_area() || !source_image_rect.encloses(region), FAILED);
/* Whether we've already set the ImageTexture to an image of the right dimensions and format,
* and so can update it without creating and setting a new image, or not. */
- const bool can_update = state_image.is_valid() && state_image->get_size() == source_image->get_size()
+ const bool can_update = state_image.is_valid() && state_image->get_size() == region.get_size()
&& state_image->get_format() == source_image->get_format();
if (!can_update) {
- state_image = Image::create(source_image->get_width(), source_image->get_height(), false, source_image->get_format());
+ state_image = Image::create(region.size.width, region.size.height, false, source_image->get_format());
ERR_FAIL_NULL_V(state_image, FAILED);
}
@@ -67,7 +69,7 @@ Error GFXButtonStateTexture::generate_state_image(Ref<Image> const& source_image
for (Vector2i point { 0, 0 }; point.y < state_image->get_height(); ++point.y) {
for (point.x = 0; point.x < state_image->get_width(); ++point.x) {
- state_image->set_pixelv(point, colour_func(source_image->get_pixelv(point)));
+ state_image->set_pixelv(point, colour_func(source_image->get_pixelv(region.position + point)));
}
}
@@ -79,16 +81,11 @@ Error GFXButtonStateTexture::generate_state_image(Ref<Image> const& source_image
return OK;
}
-StringName const& GFXButtonStateTexture::get_generate_state_image_func_name() {
- static const StringName generate_state_image_func_name = "generate_state_image";
- return generate_state_image_func_name;
-}
-
StringName const& GFXButtonStateTexture::button_state_to_theme_name(ButtonState button_state) {
static const StringName theme_name_hover = "hover";
static const StringName theme_name_pressed = "pressed";
static const StringName theme_name_disabled = "disabled";
- static const StringName theme_name_error = "";
+ static const StringName theme_name_error = "INVALID BUTTON STATE";
switch (button_state) {
case HOVER:
return theme_name_hover;
@@ -104,3 +101,39 @@ StringName const& GFXButtonStateTexture::button_state_to_theme_name(ButtonState
StringName const& GFXButtonStateTexture::get_button_state_theme() const {
return button_state_to_theme_name(button_state);
}
+
+void GFXButtonStateHavingTexture::_bind_methods() {
+ OV_BIND_METHOD(GFXButtonStateHavingTexture::get_button_state_texture, { "button_state" });
+}
+
+void GFXButtonStateHavingTexture::_update_button_states() {
+ for (Ref<GFXButtonStateTexture>& button_state_texture : button_state_textures) {
+ if (button_state_texture.is_valid()) {
+ button_state_texture->generate_state_image(button_image, get_region());
+ }
+ }
+}
+
+void GFXButtonStateHavingTexture::_clear_button_states() {
+ set_atlas(nullptr);
+ set_region({});
+ button_image.unref();
+ for (Ref<GFXButtonStateTexture>& button_state_texture : button_state_textures) {
+ button_state_texture.unref();
+ }
+}
+
+GFXButtonStateHavingTexture::GFXButtonStateHavingTexture() : button_image {}, button_state_textures {} {}
+
+Ref<GFXButtonStateTexture> GFXButtonStateHavingTexture::get_button_state_texture(
+ GFXButtonStateTexture::ButtonState button_state
+) {
+ const size_t button_state_index = button_state;
+ ERR_FAIL_COND_V(button_state_index >= button_state_textures.size(), nullptr);
+ Ref<GFXButtonStateTexture>& button_state_texture = button_state_textures[button_state_index];
+ if (button_state_texture.is_null()) {
+ button_state_texture = GFXButtonStateTexture::make_gfx_button_state_texture(button_state, button_image, get_region());
+ ERR_FAIL_NULL_V(button_state_texture, nullptr);
+ }
+ return button_state_texture;
+}
diff --git a/extension/src/openvic-extension/classes/GFXButtonStateTexture.hpp b/extension/src/openvic-extension/classes/GFXButtonStateTexture.hpp
index 32f4087..c98159d 100644
--- a/extension/src/openvic-extension/classes/GFXButtonStateTexture.hpp
+++ b/extension/src/openvic-extension/classes/GFXButtonStateTexture.hpp
@@ -1,5 +1,6 @@
#pragma once
+#include <godot_cpp/classes/atlas_texture.hpp>
#include <godot_cpp/classes/image_texture.hpp>
#include <openvic-simulation/utility/Getters.hpp>
@@ -12,7 +13,8 @@ namespace OpenVic {
enum ButtonState {
HOVER,
PRESSED,
- DISABLED
+ DISABLED,
+ BUTTON_STATE_COUNT
};
private:
@@ -27,20 +29,38 @@ namespace OpenVic {
/* Create a GFXButtonStateTexture using the specified godot::Image. Returns nullptr if generate_state_image fails. */
static godot::Ref<GFXButtonStateTexture> make_gfx_button_state_texture(
- ButtonState button_state, godot::Ref<godot::Image> const& source_image = nullptr
+ ButtonState button_state, godot::Ref<godot::Image> const& source_image, godot::Rect2i const& region
);
/* Set the ButtonState to be generated by this class (calling this does not trigger state image generation). */
void set_button_state(ButtonState new_button_state);
- /* Generate a modified version of source_image and update the underlying godot::ImageTexture to use it. */
- godot::Error generate_state_image(godot::Ref<godot::Image> const& source_image);
-
- static godot::StringName const& get_generate_state_image_func_name();
+ /* Generate a modified version of the given region of source_image
+ * and update the underlying godot::ImageTexture to use it. */
+ godot::Error generate_state_image(godot::Ref<godot::Image> const& source_image, godot::Rect2i const& region);
static godot::StringName const& button_state_to_theme_name(ButtonState button_state);
godot::StringName const& get_button_state_theme() const;
};
+
+ class GFXButtonStateHavingTexture : public godot::AtlasTexture {
+ GDCLASS(GFXButtonStateHavingTexture, godot::AtlasTexture)
+
+ std::array<godot::Ref<GFXButtonStateTexture>, GFXButtonStateTexture::BUTTON_STATE_COUNT> button_state_textures;
+
+ protected:
+ static void _bind_methods();
+
+ godot::Ref<godot::Image> button_image;
+
+ void _update_button_states();
+ void _clear_button_states();
+
+ GFXButtonStateHavingTexture();
+
+ public:
+ godot::Ref<GFXButtonStateTexture> get_button_state_texture(GFXButtonStateTexture::ButtonState button_state);
+ };
}
VARIANT_ENUM_CAST(OpenVic::GFXButtonStateTexture::ButtonState);
diff --git a/extension/src/openvic-extension/classes/GFXIconTexture.cpp b/extension/src/openvic-extension/classes/GFXIconTexture.cpp
deleted file mode 100644
index 99df7e4..0000000
--- a/extension/src/openvic-extension/classes/GFXIconTexture.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "GFXIconTexture.hpp"
-
-#include <godot_cpp/variant/utility_functions.hpp>
-
-#include "openvic-extension/singletons/AssetManager.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;
-
-using OpenVic::Utilities::std_view_to_godot_string;
-using OpenVic::Utilities::std_view_to_godot_string_name;
-
-StringName const& GFXIconTexture::_signal_image_updated() {
- static const StringName signal_image_updated = "image_updated";
- return signal_image_updated;
-}
-
-void GFXIconTexture::_bind_methods() {
- OV_BIND_METHOD(GFXIconTexture::clear);
-
- OV_BIND_METHOD(GFXIconTexture::set_gfx_texture_sprite_name, { "gfx_texture_sprite_name", "icon" }, DEFVAL(GFX::NO_FRAMES));
- OV_BIND_METHOD(GFXIconTexture::get_gfx_texture_sprite_name);
-
- OV_BIND_METHOD(GFXIconTexture::set_icon_index, { "new_icon_index" });
- OV_BIND_METHOD(GFXIconTexture::get_icon_index);
- OV_BIND_METHOD(GFXIconTexture::get_icon_count);
-
- ADD_PROPERTY(PropertyInfo(Variant::INT, "icon_index"), "set_icon_index", "get_icon_index");
-
- ADD_SIGNAL(
- MethodInfo(_signal_image_updated(), PropertyInfo(Variant::OBJECT, "source_image", PROPERTY_HINT_RESOURCE_TYPE, "Image"))
- );
-}
-
-GFXIconTexture::GFXIconTexture()
- : gfx_texture_sprite { nullptr }, icon_index { GFX::NO_FRAMES }, icon_count { GFX::NO_FRAMES } {}
-
-Ref<GFXIconTexture> GFXIconTexture::make_gfx_icon_texture(
- GFX::TextureSprite const* gfx_texture_sprite, GFX::frame_t icon,
- std::vector<Ref<GFXButtonStateTexture>> const& button_state_textures
-) {
- Ref<GFXIconTexture> icon_texture;
- icon_texture.instantiate();
- ERR_FAIL_NULL_V(icon_texture, nullptr);
-
- for (Ref<GFXButtonStateTexture> const& button_state_texture : button_state_textures) {
- icon_texture->connect(
- _signal_image_updated(),
- Callable { *button_state_texture, GFXButtonStateTexture::get_generate_state_image_func_name() },
- CONNECT_PERSIST
- );
- }
-
- ERR_FAIL_COND_V(icon_texture->set_gfx_texture_sprite(gfx_texture_sprite, icon) != OK, nullptr);
- return icon_texture;
-}
-
-void GFXIconTexture::clear() {
- gfx_texture_sprite = nullptr;
- set_atlas(nullptr);
- set_region({});
- icon_index = GFX::NO_FRAMES;
- icon_count = GFX::NO_FRAMES;
-}
-
-Error GFXIconTexture::set_gfx_texture_sprite(GFX::TextureSprite const* new_gfx_texture_sprite, GFX::frame_t icon) {
- if (gfx_texture_sprite != new_gfx_texture_sprite) {
- if (new_gfx_texture_sprite == nullptr) {
- clear();
- return OK;
- }
- AssetManager* asset_manager = AssetManager::get_singleton();
- ERR_FAIL_NULL_V(asset_manager, FAILED);
-
- const StringName texture_file = std_view_to_godot_string_name(new_gfx_texture_sprite->get_texture_file());
-
- /* Needed for GFXButtonStateTexture, AssetManager::get_texture will re-use this image from its internal cache. */
- const Ref<Image> image = asset_manager->get_image(texture_file);
- ERR_FAIL_NULL_V_MSG(image, FAILED, vformat("Failed to load image: %s", texture_file));
-
- const Ref<ImageTexture> texture = asset_manager->get_texture(texture_file);
- ERR_FAIL_NULL_V_MSG(texture, FAILED, vformat("Failed to load texture: %s", texture_file));
-
- sprite_image = image;
- gfx_texture_sprite = new_gfx_texture_sprite;
- set_atlas(texture);
- icon_index = GFX::NO_FRAMES;
- icon_count = gfx_texture_sprite->get_no_of_frames();
- }
- return set_icon_index(icon);
-}
-
-Error GFXIconTexture::set_gfx_texture_sprite_name(String const& gfx_texture_sprite_name, GFX::frame_t icon) {
- if (gfx_texture_sprite_name.is_empty()) {
- return set_gfx_texture_sprite(nullptr);
- }
- GFX::Sprite const* sprite = UITools::get_gfx_sprite(gfx_texture_sprite_name);
- ERR_FAIL_NULL_V(sprite, FAILED);
- GFX::TextureSprite const* new_texture_sprite = sprite->cast_to<GFX::TextureSprite>();
- ERR_FAIL_NULL_V_MSG(
- new_texture_sprite, FAILED, vformat(
- "Invalid type for GFX sprite %s: %s (expected %s)", gfx_texture_sprite_name,
- std_view_to_godot_string(sprite->get_type()), std_view_to_godot_string(GFX::TextureSprite::get_type_static())
- )
- );
- return set_gfx_texture_sprite(new_texture_sprite, icon);
-}
-
-String GFXIconTexture::get_gfx_texture_sprite_name() const {
- return gfx_texture_sprite != nullptr ? std_view_to_godot_string(gfx_texture_sprite->get_name()) : String {};
-}
-
-Error GFXIconTexture::set_icon_index(int32_t new_icon_index) {
- const Ref<Texture2D> atlas_texture = get_atlas();
- ERR_FAIL_NULL_V(atlas_texture, FAILED);
- const Vector2 size = atlas_texture->get_size();
- if (icon_count <= GFX::NO_FRAMES) {
- if (new_icon_index > GFX::NO_FRAMES) {
- UtilityFunctions::push_warning("Invalid icon index ", new_icon_index, " for texture with no frames!");
- }
- icon_index = GFX::NO_FRAMES;
- set_region({ {}, size });
- emit_signal(_signal_image_updated(), sprite_image);
- return OK;
- }
- if (GFX::NO_FRAMES < new_icon_index && new_icon_index <= icon_count) {
- icon_index = new_icon_index;
- } else {
- icon_index = 1;
- if (new_icon_index > icon_count) {
- UtilityFunctions::push_warning(
- "Invalid icon index ", new_icon_index, " out of count ", icon_count, " - defaulting to ", icon_index
- );
- }
- }
- set_region({ (icon_index - 1) * size.x / icon_count, 0, size.x / icon_count, size.y });
- emit_signal(_signal_image_updated(), sprite_image->get_region(get_region()));
- return OK;
-}
diff --git a/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.cpp b/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.cpp
index 0a44e56..2c315a9 100644
--- a/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.cpp
+++ b/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.cpp
@@ -13,28 +13,31 @@ using OpenVic::Utilities::godot_to_std_string;
using OpenVic::Utilities::std_view_to_godot_string;
using OpenVic::Utilities::std_view_to_godot_string_name;
-StringName const& GFXMaskedFlagTexture::_signal_image_updated() {
- static const StringName signal_image_updated = "image_updated";
- return signal_image_updated;
-}
-
Error GFXMaskedFlagTexture::_generate_combined_image() {
ERR_FAIL_NULL_V(overlay_image, FAILED);
/* Whether we've already set the ImageTexture to an image of the right dimensions and format,
* and so can update it without creating and setting a new image, or not. */
- const bool can_update = combined_image.is_valid() && combined_image->get_size() == overlay_image->get_size()
- && combined_image->get_format() == overlay_image->get_format();
+ bool can_update = button_image.is_valid() && button_image->get_size() == overlay_image->get_size()
+ && button_image->get_format() == overlay_image->get_format();
if (!can_update) {
- combined_image = Image::create(
+ button_image = Image::create(
overlay_image->get_width(), overlay_image->get_height(), false, overlay_image->get_format()
);
- ERR_FAIL_NULL_V(combined_image, FAILED);
+ ERR_FAIL_NULL_V(button_image, FAILED);
+ }
+
+ if (combined_texture.is_null()) {
+ can_update = false;
+ combined_texture.instantiate();
+ ERR_FAIL_NULL_V(combined_texture, FAILED);
+ set_atlas(combined_texture);
+ set_region({ {}, button_image->get_size() });
}
if (mask_image.is_valid() && flag_image.is_valid()) {
- const Vector2i centre_translation = (mask_image->get_size() - combined_image->get_size()) / 2;
- for (Vector2i combined_image_point { 0, 0 }; combined_image_point.y < combined_image->get_height(); ++combined_image_point.y) {
- for (combined_image_point.x = 0; combined_image_point.x < combined_image->get_width(); ++combined_image_point.x) {
+ const Vector2i centre_translation = (mask_image->get_size() - button_image->get_size()) / 2;
+ for (Vector2i combined_image_point { 0, 0 }; combined_image_point.y < button_image->get_height(); ++combined_image_point.y) {
+ for (combined_image_point.x = 0; combined_image_point.x < button_image->get_width(); ++combined_image_point.x) {
const Color overlay_image_colour = overlay_image->get_pixelv(combined_image_point);
// Translate to mask_image coordinates, keeping the centres of each image aligned.
const Vector2i mask_image_point = combined_image_point + centre_translation;
@@ -47,22 +50,22 @@ Error GFXMaskedFlagTexture::_generate_combined_image() {
const Vector2i flag_image_point = mask_image_point * flag_image->get_size() / mask_image->get_size();
Color flag_image_colour = flag_image->get_pixelv(flag_image_point);
flag_image_colour.a = mask_image_colour.a;
- combined_image->set_pixelv(combined_image_point, flag_image_colour.blend(overlay_image_colour));
+ button_image->set_pixelv(combined_image_point, flag_image_colour.blend(overlay_image_colour));
} else {
- combined_image->set_pixelv(combined_image_point, overlay_image_colour);
+ button_image->set_pixelv(combined_image_point, overlay_image_colour);
}
}
}
} else {
- combined_image->blit_rect(overlay_image, overlay_image->get_used_rect(), {});
+ button_image->blit_rect(overlay_image, overlay_image->get_used_rect(), {});
}
if (can_update) {
- update(combined_image);
+ combined_texture->update(button_image);
} else {
- set_image(combined_image);
+ combined_texture->set_image(button_image);
}
- emit_signal(_signal_image_updated(), combined_image);
+ _update_button_states();
return OK;
}
@@ -76,29 +79,14 @@ void GFXMaskedFlagTexture::_bind_methods() {
OV_BIND_METHOD(GFXMaskedFlagTexture::set_flag_country_name, { "new_flag_country_name" });
OV_BIND_METHOD(GFXMaskedFlagTexture::get_flag_country_name);
OV_BIND_METHOD(GFXMaskedFlagTexture::get_flag_type);
-
- ADD_SIGNAL(
- MethodInfo(_signal_image_updated(), PropertyInfo(Variant::OBJECT, "source_image", PROPERTY_HINT_RESOURCE_TYPE, "Image"))
- );
}
GFXMaskedFlagTexture::GFXMaskedFlagTexture() : gfx_masked_flag { nullptr }, flag_country { nullptr } {}
-Ref<GFXMaskedFlagTexture> GFXMaskedFlagTexture::make_gfx_masked_flag_texture(
- GFX::MaskedFlag const* gfx_masked_flag, std::vector<Ref<GFXButtonStateTexture>> const& button_state_textures
-) {
+Ref<GFXMaskedFlagTexture> GFXMaskedFlagTexture::make_gfx_masked_flag_texture(GFX::MaskedFlag const* gfx_masked_flag) {
Ref<GFXMaskedFlagTexture> masked_flag_texture;
masked_flag_texture.instantiate();
ERR_FAIL_NULL_V(masked_flag_texture, nullptr);
-
- for (Ref<GFXButtonStateTexture> const& button_state_texture : button_state_textures) {
- masked_flag_texture->connect(
- _signal_image_updated(),
- Callable { *button_state_texture, GFXButtonStateTexture::get_generate_state_image_func_name() },
- CONNECT_PERSIST
- );
- }
-
ERR_FAIL_COND_V(masked_flag_texture->set_gfx_masked_flag(gfx_masked_flag) != OK, nullptr);
return masked_flag_texture;
}
@@ -108,6 +96,8 @@ void GFXMaskedFlagTexture::clear() {
flag_country = nullptr;
flag_type = String {};
+ _clear_button_states();
+
overlay_image.unref();
mask_image.unref();
flag_image.unref();
diff --git a/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.hpp b/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.hpp
index 294b842..1e85dd8 100644
--- a/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.hpp
+++ b/extension/src/openvic-extension/classes/GFXMaskedFlagTexture.hpp
@@ -1,23 +1,20 @@
#pragma once
-#include <godot_cpp/classes/image_texture.hpp>
-
#include <openvic-simulation/country/Country.hpp>
#include <openvic-simulation/interface/GFX.hpp>
#include "openvic-extension/classes/GFXButtonStateTexture.hpp"
namespace OpenVic {
- class GFXMaskedFlagTexture : public godot::ImageTexture {
- GDCLASS(GFXMaskedFlagTexture, godot::ImageTexture)
+ class GFXMaskedFlagTexture : public GFXButtonStateHavingTexture {
+ GDCLASS(GFXMaskedFlagTexture, GFXButtonStateHavingTexture)
GFX::MaskedFlag const* PROPERTY(gfx_masked_flag);
Country const* PROPERTY(flag_country);
godot::StringName PROPERTY(flag_type);
- godot::Ref<godot::Image> overlay_image, mask_image, flag_image, combined_image;
-
- static godot::StringName const& _signal_image_updated();
+ godot::Ref<godot::Image> overlay_image, mask_image, flag_image;
+ godot::Ref<godot::ImageTexture> combined_texture;
godot::Error _generate_combined_image();
@@ -27,12 +24,8 @@ namespace OpenVic {
public:
GFXMaskedFlagTexture();
- /* Create a GFXMaskedFlagTexture using the specified GFX::MaskedFlag. Returns nullptr if gfx_masked_flag fails.
- * Connects the provided GFXButtonStateTextures (if any) to the GFXMaskedFlagTexture's image_updated signal. */
- static godot::Ref<GFXMaskedFlagTexture> make_gfx_masked_flag_texture(
- GFX::MaskedFlag const* gfx_masked_flag,
- std::vector<godot::Ref<GFXButtonStateTexture>> const& button_state_textures = {}
- );
+ /* Create a GFXMaskedFlagTexture using the specified GFX::MaskedFlag. Returns nullptr if gfx_masked_flag fails. */
+ static godot::Ref<GFXMaskedFlagTexture> make_gfx_masked_flag_texture(GFX::MaskedFlag const* gfx_masked_flag);
/* Reset gfx_masked_flag, flag_country and flag_type to nullptr/an empty string, and unreference all images.
* This does not affect the godot::ImageTexture, which cannot be reset to a null or empty image. */
diff --git a/extension/src/openvic-extension/classes/GFXSpriteTexture.cpp b/extension/src/openvic-extension/classes/GFXSpriteTexture.cpp
new file mode 100644
index 0000000..e002461
--- /dev/null
+++ b/extension/src/openvic-extension/classes/GFXSpriteTexture.cpp
@@ -0,0 +1,159 @@
+#include "GFXSpriteTexture.hpp"
+
+#include <godot_cpp/classes/rendering_server.hpp>
+#include <godot_cpp/variant/utility_functions.hpp>
+
+#include "openvic-extension/singletons/AssetManager.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;
+
+using OpenVic::Utilities::std_view_to_godot_string;
+using OpenVic::Utilities::std_view_to_godot_string_name;
+
+void GFXSpriteTexture::_bind_methods() {
+ OV_BIND_METHOD(GFXSpriteTexture::clear);
+
+ OV_BIND_METHOD(GFXSpriteTexture::set_gfx_texture_sprite_name, { "gfx_texture_sprite_name", "icon" }, DEFVAL(GFX::NO_FRAMES));
+ OV_BIND_METHOD(GFXSpriteTexture::get_gfx_texture_sprite_name);
+
+ OV_BIND_METHOD(GFXSpriteTexture::set_icon_index, { "new_icon_index" });
+ OV_BIND_METHOD(GFXSpriteTexture::get_icon_index);
+ OV_BIND_METHOD(GFXSpriteTexture::get_icon_count);
+
+ OV_BIND_METHOD(GFXSpriteTexture::is_cornered_tile_texture);
+ OV_BIND_METHOD(GFXSpriteTexture::draw_rect_cornered, { "to_canvas_item", "rect" });
+
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "icon_index"), "set_icon_index", "get_icon_index");
+}
+
+GFXSpriteTexture::GFXSpriteTexture()
+ : gfx_texture_sprite { nullptr }, icon_index { GFX::NO_FRAMES }, icon_count { GFX::NO_FRAMES },
+ cornered_tile_texture { false }, cornered_tile_border_size {} {}
+
+Ref<GFXSpriteTexture> GFXSpriteTexture::make_gfx_sprite_texture(GFX::TextureSprite const* gfx_texture_sprite, GFX::frame_t icon) {
+ Ref<GFXSpriteTexture> texture;
+ texture.instantiate();
+ ERR_FAIL_NULL_V(texture, nullptr);
+ ERR_FAIL_COND_V(texture->set_gfx_texture_sprite(gfx_texture_sprite, icon) != OK, nullptr);
+ return texture;
+}
+
+void GFXSpriteTexture::clear() {
+ gfx_texture_sprite = nullptr;
+ _clear_button_states();
+ icon_index = GFX::NO_FRAMES;
+ icon_count = GFX::NO_FRAMES;
+ cornered_tile_texture = false;
+ cornered_tile_border_size = {};
+}
+
+Error GFXSpriteTexture::set_gfx_texture_sprite(GFX::TextureSprite const* new_gfx_texture_sprite, GFX::frame_t icon) {
+ if (gfx_texture_sprite != new_gfx_texture_sprite) {
+ if (new_gfx_texture_sprite == nullptr) {
+ clear();
+ return OK;
+ }
+ AssetManager* asset_manager = AssetManager::get_singleton();
+ ERR_FAIL_NULL_V(asset_manager, FAILED);
+
+ const StringName texture_file = std_view_to_godot_string_name(new_gfx_texture_sprite->get_texture_file());
+
+ /* Needed for GFXButtonStateTexture, AssetManager::get_texture will re-use this image from its internal cache. */
+ const Ref<Image> image = asset_manager->get_image(texture_file);
+ ERR_FAIL_NULL_V_MSG(image, FAILED, vformat("Failed to load image: %s", texture_file));
+
+ const Ref<ImageTexture> texture = asset_manager->get_texture(texture_file);
+ ERR_FAIL_NULL_V_MSG(texture, FAILED, vformat("Failed to load texture: %s", texture_file));
+
+ button_image = image;
+ gfx_texture_sprite = new_gfx_texture_sprite;
+ set_atlas(texture);
+ icon_index = GFX::NO_FRAMES;
+
+ GFX::IconTextureSprite const* const icon_texture_sprite = gfx_texture_sprite->cast_to<GFX::IconTextureSprite>();
+ if (icon_texture_sprite != nullptr) {
+ icon_count = icon_texture_sprite->get_no_of_frames();
+ } else {
+ icon_count = GFX::NO_FRAMES;
+ }
+
+ GFX::CorneredTileTextureSprite const* const cornered_tile_texture_sprite =
+ gfx_texture_sprite->cast_to<GFX::CorneredTileTextureSprite>();
+ if (cornered_tile_texture_sprite != nullptr) {
+ cornered_tile_texture = true;
+ cornered_tile_border_size = Utilities::to_godot_ivec2(cornered_tile_texture_sprite->get_border_size());
+ } else {
+ cornered_tile_texture = false;
+ cornered_tile_border_size = {};
+ }
+ }
+ return set_icon_index(icon);
+}
+
+Error GFXSpriteTexture::set_gfx_texture_sprite_name(String const& gfx_texture_sprite_name, GFX::frame_t icon) {
+ if (gfx_texture_sprite_name.is_empty()) {
+ return set_gfx_texture_sprite(nullptr);
+ }
+ GFX::Sprite const* sprite = UITools::get_gfx_sprite(gfx_texture_sprite_name);
+ ERR_FAIL_NULL_V(sprite, FAILED);
+ GFX::TextureSprite const* new_texture_sprite = sprite->cast_to<GFX::TextureSprite>();
+ ERR_FAIL_NULL_V_MSG(
+ new_texture_sprite, FAILED, vformat(
+ "Invalid type for GFX sprite %s: %s (expected %s)", gfx_texture_sprite_name,
+ std_view_to_godot_string(sprite->get_type()), std_view_to_godot_string(GFX::TextureSprite::get_type_static())
+ )
+ );
+ return set_gfx_texture_sprite(new_texture_sprite, icon);
+}
+
+String GFXSpriteTexture::get_gfx_texture_sprite_name() const {
+ return gfx_texture_sprite != nullptr ? std_view_to_godot_string(gfx_texture_sprite->get_name()) : String {};
+}
+
+Error GFXSpriteTexture::set_icon_index(int32_t new_icon_index) {
+ const Ref<Texture2D> atlas_texture = get_atlas();
+ ERR_FAIL_NULL_V(atlas_texture, FAILED);
+ const Vector2 size = atlas_texture->get_size();
+ if (icon_count <= GFX::NO_FRAMES) {
+ if (new_icon_index > GFX::NO_FRAMES) {
+ UtilityFunctions::push_warning("Invalid icon index ", new_icon_index, " for texture with no frames!");
+ }
+ icon_index = GFX::NO_FRAMES;
+ set_region({ {}, size });
+ } else {
+ if (GFX::NO_FRAMES < new_icon_index && new_icon_index <= icon_count) {
+ icon_index = new_icon_index;
+ } else {
+ icon_index = 1;
+ if (new_icon_index > icon_count) {
+ UtilityFunctions::push_warning(
+ "Invalid icon index ", new_icon_index, " out of count ", icon_count, " - defaulting to ", icon_index
+ );
+ }
+ }
+ set_region({ (icon_index - 1) * size.x / icon_count, 0, size.x / icon_count, size.y });
+ }
+ _update_button_states();
+ return OK;
+}
+
+void GFXSpriteTexture::draw_rect_cornered(RID const& to_canvas_item, Rect2 const& rect) const {
+ const Ref<Texture2D> atlas_texture = get_atlas();
+ if (atlas_texture.is_valid()) {
+ if (cornered_tile_texture) {
+ RenderingServer* rendering_server = RenderingServer::get_singleton();
+ if (rendering_server != nullptr) {
+ rendering_server->canvas_item_add_nine_patch(
+ to_canvas_item, rect, { {}, atlas_texture->get_size() }, atlas_texture->get_rid(),
+ cornered_tile_border_size, atlas_texture->get_size() - cornered_tile_border_size
+ );
+ }
+ } else {
+ draw_rect(to_canvas_item, rect, false);
+ }
+ }
+}
diff --git a/extension/src/openvic-extension/classes/GFXIconTexture.hpp b/extension/src/openvic-extension/classes/GFXSpriteTexture.hpp
index 06dac34..783dfba 100644
--- a/extension/src/openvic-extension/classes/GFXIconTexture.hpp
+++ b/extension/src/openvic-extension/classes/GFXSpriteTexture.hpp
@@ -7,39 +7,37 @@
#include "openvic-extension/classes/GFXButtonStateTexture.hpp"
namespace OpenVic {
- class GFXIconTexture : public godot::AtlasTexture {
- GDCLASS(GFXIconTexture, godot::AtlasTexture)
+ class GFXSpriteTexture : public GFXButtonStateHavingTexture {
+ GDCLASS(GFXSpriteTexture, GFXButtonStateHavingTexture)
/* PROPERTY automatically defines getter functions:
* - get_gfx_texture_sprite
* - get_icon_index
- * - get_icon_count */
+ * - get_icon_count
+ * - is_cornered_tile_texture */
GFX::TextureSprite const* PROPERTY(gfx_texture_sprite);
GFX::frame_t PROPERTY(icon_index);
GFX::frame_t PROPERTY(icon_count);
-
- godot::Ref<godot::Image> sprite_image;
-
- static godot::StringName const& _signal_image_updated();
+ bool PROPERTY_CUSTOM_PREFIX(cornered_tile_texture, is);
+ godot::Vector2i cornered_tile_border_size;
protected:
static void _bind_methods();
public:
- GFXIconTexture();
-
- /* Create a GFXIconTexture using the specified GFX::TextureSprite and icon index. Returns nullptr if
- * set_gfx_texture_sprite fails. Connects the provided GFXButtonStateTextures (if any) to the
- * GFXIconTexture's image_updated signal. */
- static godot::Ref<GFXIconTexture> make_gfx_icon_texture(
- GFX::TextureSprite const* gfx_texture_sprite, GFX::frame_t icon = GFX::NO_FRAMES,
- std::vector<godot::Ref<GFXButtonStateTexture>> const& button_state_textures = {}
+ GFXSpriteTexture();
+
+ /* Create a GFXSpriteTexture using the specified GFX::TextureSprite and icon index. Returns nullptr if
+ * set_gfx_texture_sprite fails. */
+ static godot::Ref<GFXSpriteTexture> make_gfx_sprite_texture(
+ GFX::TextureSprite const* gfx_texture_sprite, GFX::frame_t icon = GFX::NO_FRAMES
);
/* Discard the GFX::TextureSprite, atlas texture and icon index. */
void clear();
- /* Set the GFX::TextureSprite, load its texture as an atlas and set its displayed icon */
+ /* Set the GFX::TextureSprite, load its texture as an atlas, check if it is an IconTextureSprite,
+ * and if so set its icon count and the current displayed icon. */
godot::Error set_gfx_texture_sprite(
GFX::TextureSprite const* new_gfx_texture_sprite, GFX::frame_t icon = GFX::NO_FRAMES
);
@@ -58,5 +56,8 @@ namespace OpenVic {
* If zero is used but icon_count is non-zero, icon_index defaults to icon_count (the last frame,
* not the first frame because it is often empty). */
godot::Error set_icon_index(GFX::frame_t new_icon_index);
+
+ /* Equivalent to draw_rect, but draws a 9 patch texture if this is a cornered tile texture. */
+ void draw_rect_cornered(godot::RID const& to_canvas_item, godot::Rect2 const& rect) const;
};
}
diff --git a/extension/src/openvic-extension/classes/GUINode.cpp b/extension/src/openvic-extension/classes/GUINode.cpp
index f95e3cd..a038df7 100644
--- a/extension/src/openvic-extension/classes/GUINode.cpp
+++ b/extension/src/openvic-extension/classes/GUINode.cpp
@@ -20,7 +20,7 @@ using namespace OpenVic;
F(GUIOverlappingElementsBox, gui_overlapping_elements_box)
#define APPLY_TO_TEXTURE_TYPES(F) \
- F(GFXIconTexture, gfx_icon_texture) \
+ F(GFXSpriteTexture, gfx_sprite_texture) \
F(GFXMaskedFlagTexture, gfx_masked_flag_texture) \
F(GFXPieChartTexture, gfx_pie_chart_texture)
diff --git a/extension/src/openvic-extension/classes/GUINode.hpp b/extension/src/openvic-extension/classes/GUINode.hpp
index 0fbfc66..42074e3 100644
--- a/extension/src/openvic-extension/classes/GUINode.hpp
+++ b/extension/src/openvic-extension/classes/GUINode.hpp
@@ -9,7 +9,7 @@
#include <openvic-simulation/interface/GUI.hpp>
-#include "openvic-extension/classes/GFXIconTexture.hpp"
+#include "openvic-extension/classes/GFXSpriteTexture.hpp"
#include "openvic-extension/classes/GFXMaskedFlagTexture.hpp"
#include "openvic-extension/classes/GFXPieChartTexture.hpp"
#include "openvic-extension/classes/GUIOverlappingElementsBox.hpp"
@@ -52,12 +52,12 @@ namespace OpenVic {
/* Helper functions to get textures from TextureRects and Buttons. */
static godot::Ref<godot::Texture2D> get_texture_from_node(godot::Node* node);
- static godot::Ref<GFXIconTexture> get_gfx_icon_texture_from_node(godot::Node* node);
+ static godot::Ref<GFXSpriteTexture> get_gfx_sprite_texture_from_node(godot::Node* node);
static godot::Ref<GFXMaskedFlagTexture> get_gfx_masked_flag_texture_from_node(godot::Node* node);
static godot::Ref<GFXPieChartTexture> get_gfx_pie_chart_texture_from_node(godot::Node* node);
godot::Ref<godot::Texture2D> get_texture_from_nodepath(godot::NodePath const& path) const;
- godot::Ref<GFXIconTexture> get_gfx_icon_texture_from_nodepath(godot::NodePath const& path) const;
+ godot::Ref<GFXSpriteTexture> get_gfx_sprite_texture_from_nodepath(godot::NodePath const& path) const;
godot::Ref<GFXMaskedFlagTexture> get_gfx_masked_flag_texture_from_nodepath(godot::NodePath const& path) const;
godot::Ref<GFXPieChartTexture> get_gfx_pie_chart_texture_from_nodepath(godot::NodePath const& path) const;
diff --git a/extension/src/openvic-extension/register_types.cpp b/extension/src/openvic-extension/register_types.cpp
index 046bc60..431de02 100644
--- a/extension/src/openvic-extension/register_types.cpp
+++ b/extension/src/openvic-extension/register_types.cpp
@@ -3,7 +3,7 @@
#include <godot_cpp/classes/engine.hpp>
#include "openvic-extension/classes/GFXButtonStateTexture.hpp"
-#include "openvic-extension/classes/GFXIconTexture.hpp"
+#include "openvic-extension/classes/GFXSpriteTexture.hpp"
#include "openvic-extension/classes/GFXMaskedFlagTexture.hpp"
#include "openvic-extension/classes/GFXPieChartTexture.hpp"
#include "openvic-extension/classes/GUINode.hpp"
@@ -45,7 +45,8 @@ void initialize_openvic_types(ModuleInitializationLevel p_level) {
ClassDB::register_class<MapMesh>();
ClassDB::register_class<GFXButtonStateTexture>();
- ClassDB::register_class<GFXIconTexture>();
+ ClassDB::register_abstract_class<GFXButtonStateHavingTexture>();
+ ClassDB::register_class<GFXSpriteTexture>();
ClassDB::register_class<GFXMaskedFlagTexture>();
ClassDB::register_class<GFXPieChartTexture>();
ClassDB::register_class<GUINode>();
diff --git a/extension/src/openvic-extension/utility/UITools.cpp b/extension/src/openvic-extension/utility/UITools.cpp
index 1fcc574..a3e70b5 100644
--- a/extension/src/openvic-extension/utility/UITools.cpp
+++ b/extension/src/openvic-extension/utility/UITools.cpp
@@ -12,7 +12,7 @@
#include <godot_cpp/variant/utility_functions.hpp>
#include "openvic-extension/classes/GFXButtonStateTexture.hpp"
-#include "openvic-extension/classes/GFXIconTexture.hpp"
+#include "openvic-extension/classes/GFXSpriteTexture.hpp"
#include "openvic-extension/classes/GFXMaskedFlagTexture.hpp"
#include "openvic-extension/classes/GFXPieChartTexture.hpp"
#include "openvic-extension/classes/GUIOverlappingElementsBox.hpp"
@@ -128,17 +128,17 @@ static bool generate_icon(generate_gui_args_t&& args) {
/* Change to use sprite type to choose Godot node type! */
bool ret = true;
if (icon.get_sprite() != nullptr) {
- if (icon.get_sprite()->is_type<GFX::TextureSprite>()) {
+ if (icon.get_sprite()->is_type<GFX::IconTextureSprite>()) {
TextureRect* godot_texture_rect = nullptr;
ret &= new_control(godot_texture_rect, icon, args.name);
ERR_FAIL_NULL_V_MSG(godot_texture_rect, false, vformat("Failed to create TextureRect for GUI icon %s", icon_name));
- GFX::TextureSprite const* texture_sprite = icon.get_sprite()->cast_to<GFX::TextureSprite>();
- Ref<GFXIconTexture> texture = GFXIconTexture::make_gfx_icon_texture(texture_sprite, icon.get_frame());
+ GFX::IconTextureSprite const* texture_sprite = icon.get_sprite()->cast_to<GFX::IconTextureSprite>();
+ Ref<GFXSpriteTexture> texture = GFXSpriteTexture::make_gfx_sprite_texture(texture_sprite, icon.get_frame());
if (texture.is_valid()) {
godot_texture_rect->set_texture(texture);
} else {
- UtilityFunctions::push_error("Failed to make GFXIconTexture for GUI icon ", icon_name);
+ UtilityFunctions::push_error("Failed to make GFXSpriteTexture for GUI icon ", icon_name);
ret = false;
}
@@ -290,35 +290,18 @@ static bool generate_button(generate_gui_args_t&& args) {
godot_button->set_text(std_view_to_godot_string(button.get_text()));
}
- using enum GFXButtonStateTexture::ButtonState;
- static constexpr std::array<GFXButtonStateTexture::ButtonState, 3> button_states { HOVER, PRESSED, DISABLED };
-
- std::vector<Ref<GFXButtonStateTexture>> button_state_textures;
- for (GFXButtonStateTexture::ButtonState button_state : button_states) {
- Ref<GFXButtonStateTexture> button_state_texture = GFXButtonStateTexture::make_gfx_button_state_texture(button_state);
- if (button_state_texture.is_valid()) {
- button_state_textures.push_back(button_state_texture);
- } else {
- UtilityFunctions::push_error(
- "Failed to make ", GFXButtonStateTexture::button_state_to_theme_name(button_state),
- " GFXButtonStateTexture for GUI button ", button_name
- );
- ret = false;
- }
- }
-
if (button.get_sprite() != nullptr) {
- Ref<Texture2D> texture;
- if (button.get_sprite()->is_type<GFX::TextureSprite>()) {
- GFX::TextureSprite const* texture_sprite = button.get_sprite()->cast_to<GFX::TextureSprite>();
- texture = GFXIconTexture::make_gfx_icon_texture(texture_sprite, 0, button_state_textures);
+ Ref<GFXButtonStateHavingTexture> texture;
+ if (button.get_sprite()->is_type<GFX::IconTextureSprite>()) {
+ GFX::IconTextureSprite const* texture_sprite = button.get_sprite()->cast_to<GFX::IconTextureSprite>();
+ texture = GFXSpriteTexture::make_gfx_sprite_texture(texture_sprite);
if (texture.is_null()) {
- UtilityFunctions::push_error("Failed to make GFXIconTexture for GUI button ", button_name);
+ UtilityFunctions::push_error("Failed to make GFXSpriteTexture for GUI button ", button_name);
ret = false;
}
} else if (button.get_sprite()->is_type<GFX::MaskedFlag>()) {
GFX::MaskedFlag const* masked_flag = button.get_sprite()->cast_to<GFX::MaskedFlag>();
- texture = GFXMaskedFlagTexture::make_gfx_masked_flag_texture(masked_flag, button_state_textures);
+ texture = GFXMaskedFlagTexture::make_gfx_masked_flag_texture(masked_flag);
if (texture.is_null()) {
UtilityFunctions::push_error("Failed to make GFXMaskedFlagTexture for GUI button ", button_name);
ret = false;
@@ -332,20 +315,23 @@ static bool generate_button(generate_gui_args_t&& args) {
if (texture.is_valid()) {
godot_button->set_custom_minimum_size(texture->get_size());
- const auto add_stylebox = [godot_button, &button_name](StringName const& theme_name, Ref<Texture2D> const& texture) -> bool {
- Ref<StyleBoxTexture> stylebox;
- stylebox.instantiate();
- ERR_FAIL_NULL_V(stylebox, false);
- stylebox->set_texture(texture);
- godot_button->add_theme_stylebox_override(theme_name, stylebox);
- return true;
- };
-
static const StringName theme_name_normal = "normal";
ret &= add_theme_stylebox(godot_button, theme_name_normal, texture);
- for (Ref<GFXButtonStateTexture> const& button_state_texture : button_state_textures) {
- ret &= add_theme_stylebox(godot_button, button_state_texture->get_button_state_theme(), button_state_texture);
+ using enum GFXButtonStateTexture::ButtonState;
+ for (GFXButtonStateTexture::ButtonState button_state : { HOVER, PRESSED, DISABLED }) {
+ Ref<GFXButtonStateTexture> button_state_texture = texture->get_button_state_texture(button_state);
+ if (button_state_texture.is_valid()) {
+ ret &= add_theme_stylebox(
+ godot_button, button_state_texture->get_button_state_theme(), button_state_texture
+ );
+ } else {
+ UtilityFunctions::push_error(
+ "Failed to make ", GFXButtonStateTexture::button_state_to_theme_name(button_state),
+ " GFXButtonStateTexture for GUI button ", button_name
+ );
+ ret = false;
+ }
}
}
} else {
@@ -387,21 +373,21 @@ static bool generate_checkbox(generate_gui_args_t&& args) {
ERR_FAIL_NULL_V_MSG(godot_checkbox, false, vformat("Failed to create CheckBox for GUI checkbox %s", checkbox_name));
if (checkbox.get_sprite() != nullptr) {
- GFX::TextureSprite const* texture_sprite = checkbox.get_sprite()->cast_to<GFX::TextureSprite>();
+ GFX::IconTextureSprite const* texture_sprite = checkbox.get_sprite()->cast_to<GFX::IconTextureSprite>();
if (texture_sprite != nullptr) {
- Ref<GFXIconTexture> icon_texture = GFXIconTexture::make_gfx_icon_texture(texture_sprite, 1);
+ Ref<GFXSpriteTexture> icon_texture = GFXSpriteTexture::make_gfx_sprite_texture(texture_sprite, 1);
if (icon_texture.is_valid()) {
godot_checkbox->set_custom_minimum_size(icon_texture->get_size());
godot_checkbox->add_theme_icon_override("unchecked", icon_texture);
} else {
- UtilityFunctions::push_error("Failed to make unchecked GFXIconTexture for GUI checkbox ", checkbox_name);
+ UtilityFunctions::push_error("Failed to make unchecked GFXSpriteTexture for GUI checkbox ", checkbox_name);
ret = false;
}
- icon_texture = GFXIconTexture::make_gfx_icon_texture(texture_sprite, 2);
+ icon_texture = GFXSpriteTexture::make_gfx_sprite_texture(texture_sprite, 2);
if (icon_texture.is_valid()) {
godot_checkbox->add_theme_icon_override("checked", icon_texture);
} else {
- UtilityFunctions::push_error("Failed to make checked GFXIconTexture for GUI checkbox ", checkbox_name);
+ UtilityFunctions::push_error("Failed to make checked GFXSpriteTexture for GUI checkbox ", checkbox_name);
ret = false;
}
} else {