aboutsummaryrefslogtreecommitdiff
path: root/extension/src/openvic-extension/singletons/AssetManager.cpp
blob: d17edd0dd806eed3668fa3548edb6d656cc1d319 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
#include "AssetManager.hpp"

#include <godot_cpp/variant/utility_functions.hpp>

#include "openvic-extension/singletons/GameSingleton.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;

void AssetManager::_bind_methods() {
   OV_BIND_METHOD(AssetManager::get_image, { "path", "load_flags" }, DEFVAL(LOAD_FLAG_CACHE_IMAGE));
   OV_BIND_METHOD(AssetManager::get_texture, { "path", "load_flags" }, DEFVAL(LOAD_FLAG_CACHE_TEXTURE));
   OV_BIND_METHOD(AssetManager::get_font, { "name" });

   BIND_ENUM_CONSTANT(LOAD_FLAG_NONE);
   BIND_ENUM_CONSTANT(LOAD_FLAG_CACHE_IMAGE);
   BIND_ENUM_CONSTANT(LOAD_FLAG_CACHE_TEXTURE);
   BIND_ENUM_CONSTANT(LOAD_FLAG_FLIP_Y);
}

AssetManager* AssetManager::get_singleton() {
   return _singleton;
}

AssetManager::AssetManager() {
   ERR_FAIL_COND(_singleton != nullptr);
   _singleton = this;
}

AssetManager::~AssetManager() {
   ERR_FAIL_COND(_singleton != this);
   _singleton = nullptr;
}

Ref<Image> AssetManager::_load_image(StringName const& path, bool flip_y) {
   GameSingleton* game_singleton = GameSingleton::get_singleton();
   ERR_FAIL_NULL_V(game_singleton, nullptr);

   const String lookedup_path = Utilities::std_to_godot_string(
      game_singleton->get_dataloader().lookup_image_file(Utilities::godot_to_std_string(path)).string()
   );
   ERR_FAIL_COND_V_MSG(lookedup_path.is_empty(), nullptr, vformat("Failed to look up image: %s", path));

   const Ref<Image> image = Utilities::load_godot_image(lookedup_path);
   ERR_FAIL_COND_V_MSG(
      image.is_null() || image->is_empty(), nullptr,
      vformat("Failed to load image: %s (looked up: %s)", path, lookedup_path)
   );

   if (flip_y) {
      image->flip_y();
   }

   return image;
}

Ref<Image> AssetManager::get_image(StringName const& path, LoadFlags load_flags) {
   /* Check for an existing image entry indicating a previous load attempt, whether successful or not. */
   const image_asset_map_t::iterator it = image_assets.find(path);
   if (it != image_assets.end()) {
      std::optional<Ref<Image>> const& cached_image = it->second.image;

      if (cached_image.has_value()) {
         ERR_FAIL_NULL_V_MSG(*cached_image, nullptr, vformat("Failed to load image previously: %s", path));

         return *cached_image;
      }
   }

   /* No load attempt has been made yet, so we try now. */
   const Ref<Image> image = _load_image(path, load_flags & LOAD_FLAG_FLIP_Y);

   if (image.is_valid()) {
      if (load_flags & LOAD_FLAG_CACHE_IMAGE) {
         image_assets[path].image = image;
      }

      return image;
   } else {
      /* Mark both image and texture as failures, regardless of cache flags, in case of future load/creation attempts. */
      image_assets[path] = { nullptr, nullptr };

      ERR_FAIL_V_MSG(nullptr, vformat("Failed to load image: %s", path));
   }
}

Ref<ImageTexture> AssetManager::get_texture(StringName const& path, LoadFlags load_flags) {
   /* Check for an existing texture entry indicating a previous creation attempt, whether successful or not. */
   const image_asset_map_t::const_iterator it = image_assets.find(path);
   if (it != image_assets.end()) {
      std::optional<Ref<ImageTexture>> const& cached_texture = it->second.texture;

      if (cached_texture.has_value()) {
         ERR_FAIL_NULL_V_MSG(*cached_texture, nullptr, vformat("Failed to create texture previously: %s", path));

         return *cached_texture;
      }
   }

   /* No creation attempt has yet been made, so we try now starting by finding the corresponding image. */
   const Ref<Image> image = get_image(path, load_flags);
   ERR_FAIL_NULL_V_MSG(image, nullptr, vformat("Failed to load image for texture: %s", path));

   const Ref<ImageTexture> texture = ImageTexture::create_from_image(image);

   if (texture.is_valid()) {
      if (load_flags & LOAD_FLAG_CACHE_TEXTURE) {
         image_assets[path].texture = texture;
      }

      return texture;
   } else {
      /* Mark texture as a failure, regardless of cache flags, in case of future creation attempts. */
      image_assets[path].texture = nullptr;

      ERR_FAIL_V_MSG(nullptr, vformat("Failed to create texture: %s", path));
   }
}

Ref<FontFile> AssetManager::get_font(StringName const& name) {
   const font_map_t::const_iterator it = fonts.find(name);
   if (it != fonts.end()) {
      ERR_FAIL_NULL_V_MSG(it->second, nullptr, vformat("Failed to load font previously: %s", name));

      return it->second;
   }

   static const String font_dir = "gfx/fonts/";
   static const String font_ext = ".fnt";
   static const String image_ext = ".tga";

   const StringName image_path = font_dir + name + image_ext;
   const Ref<Image> image = get_image(image_path, LOAD_FLAG_NONE);
   if (image.is_null()) {
      fonts.emplace(name, nullptr);

      ERR_FAIL_V_MSG(nullptr, vformat("Failed to load font image %s for the font named %s", image_path, name));
   }

   GameSingleton* game_singleton = GameSingleton::get_singleton();
   ERR_FAIL_NULL_V(game_singleton, nullptr);

   const String font_path = font_dir + name + font_ext;
   const String lookedup_font_path = Utilities::std_to_godot_string(
      game_singleton->get_dataloader().lookup_file(Utilities::godot_to_std_string(font_path)).string()
   );
   if (lookedup_font_path.is_empty()) {
      fonts.emplace(name, nullptr);

      ERR_FAIL_V_MSG(nullptr, vformat("Failed to look up font: %s", font_path));
   }

   const Ref<FontFile> font = Utilities::load_godot_font(lookedup_font_path, image);
   if (font.is_null()) {
      fonts.emplace(name, nullptr);

      ERR_FAIL_V_MSG(
         nullptr,
         vformat("Failed to load font file %s (looked up: %s) for the font named %s", font_path, lookedup_font_path, name)
      );
   }

   fonts.emplace(name, font);
   return font;
}

Error AssetManager::preload_textures() {
   static const String currency_sprite_big = "GFX_tooltip_money_big";
   static const String currency_sprite_medium = "GFX_tooltip_money_small";
   static const String currency_sprite_small = "GFX_tooltip_money";

   constexpr auto load = [](String const& sprite_name, Ref<GFXSpriteTexture>& texture) -> bool {
      GFX::Sprite const* sprite = UITools::get_gfx_sprite(sprite_name);
      ERR_FAIL_NULL_V(sprite, false);

      GFX::IconTextureSprite const* icon_sprite = sprite->cast_to<GFX::IconTextureSprite>();
      ERR_FAIL_NULL_V(icon_sprite, false);

      texture = GFXSpriteTexture::make_gfx_sprite_texture(icon_sprite);
      ERR_FAIL_NULL_V(texture, false);

      return true;
   };

   bool ret = true;

   ret &= load(currency_sprite_big, currency_texture_big);
   ret &= load(currency_sprite_medium, currency_texture_medium);
   ret &= load(currency_sprite_small, currency_texture_small);

   return ERR(ret);
}

Ref<GFXSpriteTexture> const& AssetManager::get_currency_texture(real_t height) const {
   if (height > currency_texture_big->get_height()) {
      return currency_texture_big;
   } else if (height > currency_texture_medium->get_height()) {
      return currency_texture_medium;
   } else {
      return currency_texture_small;
   }
}