dfhack/library/modules/Textures.cpp

252 lines
7.6 KiB
C++

2023-08-11 00:14:05 -06:00
#include <mutex>
#include <unordered_map>
#include "Internal.h"
2023-01-04 18:15:32 -07:00
#include "modules/DFSDL.h"
#include "modules/Textures.h"
#include "Debug.h"
#include "PluginManager.h"
2023-08-11 00:14:05 -06:00
#include "VTableInterpose.h"
#include "df/enabler.h"
2023-08-11 00:14:05 -06:00
#include "df/viewscreen_adopt_regionst.h"
#include "df/viewscreen_loadgamest.h"
#include "df/viewscreen_new_arenast.h"
2023-08-12 07:11:42 -06:00
#include "df/viewscreen_new_regionst.h"
2023-05-22 16:07:19 -06:00
2023-08-12 23:33:31 -06:00
#include <SDL_surface.h>
using df::global::enabler;
using namespace DFHack;
2023-01-04 18:15:32 -07:00
using namespace DFHack::DFSDL;
namespace DFHack {
2023-08-12 23:33:31 -06:00
DBG_DECLARE(core, textures, DebugCategory::LINFO);
}
2023-08-11 00:14:05 -06:00
static std::unordered_map<TexposHandle, long> g_handle_to_texpos;
static std::unordered_map<TexposHandle, SDL_Surface*> g_handle_to_surface;
static std::mutex g_adding_mutex;
// Converts an arbitrary Surface to something like the display format
// (32-bit RGBA), and converts magenta to transparency if convert_magenta is set
// and the source surface didn't already have an alpha channel.
// It also deletes the source surface.
//
// It uses the same pixel format (RGBA, R at lowest address) regardless of
// hardware.
2023-08-11 12:40:41 -06:00
SDL_Surface* canonicalize_format(SDL_Surface* src) {
2023-08-12 07:11:42 -06:00
SDL_PixelFormat fmt;
fmt.palette = NULL;
fmt.BitsPerPixel = 32;
fmt.BytesPerPixel = 4;
fmt.Rloss = fmt.Gloss = fmt.Bloss = fmt.Aloss = 0;
2023-05-22 16:07:19 -06:00
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
2023-08-12 07:11:42 -06:00
fmt.Rshift = 24;
fmt.Gshift = 16;
fmt.Bshift = 8;
fmt.Ashift = 0;
2023-05-22 16:07:19 -06:00
#else
2023-08-12 07:11:42 -06:00
fmt.Rshift = 0;
fmt.Gshift = 8;
fmt.Bshift = 16;
fmt.Ashift = 24;
2023-05-22 16:07:19 -06:00
#endif
2023-08-12 07:11:42 -06:00
fmt.Rmask = 255 << fmt.Rshift;
fmt.Gmask = 255 << fmt.Gshift;
fmt.Bmask = 255 << fmt.Bshift;
fmt.Amask = 255 << fmt.Ashift;
SDL_Surface* tgt = DFSDL_ConvertSurface(src, &fmt, SDL_SWSURFACE);
DFSDL_FreeSurface(src);
for (int x = 0; x < tgt->w; ++x) {
for (int y = 0; y < tgt->h; ++y) {
Uint8* p = (Uint8*)tgt->pixels + y * tgt->pitch + x * 4;
if (p[3] == 0) {
for (int c = 0; c < 3; c++) {
p[c] = 0;
}
}
}
}
return tgt;
}
2023-08-11 00:14:05 -06:00
// register surface in texture raws, get a texpos
static long add_texture(SDL_Surface* surface) {
std::lock_guard<std::mutex> lg_add_texture(g_adding_mutex);
auto texpos = enabler->textures.raws.size();
enabler->textures.raws.push_back(surface);
return texpos;
}
TexposHandle Textures::loadTexture(SDL_Surface* surface) {
if (!surface)
return 0; // should be some error, i guess
2023-08-13 11:09:12 -06:00
auto handle = reinterpret_cast<uintptr_t>(surface);
2023-08-11 00:14:05 -06:00
g_handle_to_surface.emplace(handle, surface);
surface->refcount++; // prevent destruct on next FreeSurface by game
auto texpos = add_texture(surface);
g_handle_to_texpos.emplace(handle, texpos);
return handle;
}
2023-08-12 23:33:31 -06:00
std::vector<TexposHandle> Textures::loadTileset(const std::string& file, int tile_px_w,
int tile_px_h) {
2023-08-11 12:40:41 -06:00
std::vector<TexposHandle> handles{};
SDL_Surface* surface = DFIMG_Load(file.c_str());
if (!surface) {
ERR(textures).printerr("unable to load textures from '%s'\n", file.c_str());
return handles;
}
surface = canonicalize_format(surface);
int dimx = surface->w / tile_px_w;
int dimy = surface->h / tile_px_h;
for (int y = 0; y < dimy; y++) {
for (int x = 0; x < dimx; x++) {
2023-08-12 07:11:42 -06:00
SDL_Surface* tile = DFSDL_CreateRGBSurface(
0, tile_px_w, tile_px_h, 32, surface->format->Rmask, surface->format->Gmask,
surface->format->Bmask, surface->format->Amask);
SDL_Rect vp{tile_px_w * x, tile_px_h * y, tile_px_w, tile_px_h};
2023-08-11 12:40:41 -06:00
DFSDL_UpperBlit(surface, &vp, tile, NULL);
auto handle = Textures::loadTexture(tile);
handles.push_back(handle);
}
}
DFSDL_FreeSurface(surface);
2023-08-16 21:32:26 -06:00
DEBUG(textures).print("loaded %zd textures from '%s'\n", handles.size(), file.c_str());
2023-08-11 12:40:41 -06:00
return handles;
}
long Textures::getTexposByHandle(TexposHandle handle) {
2023-08-11 00:14:05 -06:00
if (!handle)
2023-08-11 12:40:41 -06:00
return -1;
2023-08-11 00:14:05 -06:00
2023-08-11 12:40:41 -06:00
if (g_handle_to_texpos.contains(handle))
return g_handle_to_texpos[handle];
2023-08-11 00:14:05 -06:00
2023-08-11 12:40:41 -06:00
if (g_handle_to_surface.contains(handle)) {
g_handle_to_surface[handle]->refcount++; // prevent destruct on next FreeSurface by game
auto texpos = add_texture(g_handle_to_surface[handle]);
g_handle_to_texpos.emplace(handle, texpos);
return texpos;
2023-08-11 00:14:05 -06:00
}
2023-08-11 12:40:41 -06:00
return -1;
2023-08-11 00:14:05 -06:00
}
static void reset_texpos() {
g_handle_to_texpos.clear();
}
static void reset_surface() {
for (auto& entry : g_handle_to_surface) {
DFSDL_FreeSurface(entry.second);
}
g_handle_to_surface.clear();
}
// reset point on New Game
struct tracking_stage_new_region : df::viewscreen_new_regionst {
typedef df::viewscreen_new_regionst interpose_base;
DEFINE_VMETHOD_INTERPOSE(void, logic, ()) {
if (this->m_raw_load_stage != this->raw_load_stage) {
this->m_raw_load_stage = this->raw_load_stage;
if (this->m_raw_load_stage == 1)
reset_texpos();
}
INTERPOSE_NEXT(logic)();
}
private:
inline static int m_raw_load_stage = -2; // not valid state at the start
};
IMPLEMENT_VMETHOD_INTERPOSE(tracking_stage_new_region, logic);
// reset point on New Game in Existing World
struct tracking_stage_adopt_region : df::viewscreen_adopt_regionst {
typedef df::viewscreen_adopt_regionst interpose_base;
DEFINE_VMETHOD_INTERPOSE(void, logic, ()) {
if (this->m_cur_step != this->cur_step) {
this->m_cur_step = this->cur_step;
2023-08-27 13:28:03 -06:00
if (this->m_cur_step == 1)
2023-08-11 00:14:05 -06:00
reset_texpos();
}
INTERPOSE_NEXT(logic)();
}
private:
inline static int m_cur_step = -2; // not valid state at the start
};
IMPLEMENT_VMETHOD_INTERPOSE(tracking_stage_adopt_region, logic);
// reset point on Load Game
struct tracking_stage_load_region : df::viewscreen_loadgamest {
typedef df::viewscreen_loadgamest interpose_base;
DEFINE_VMETHOD_INTERPOSE(void, logic, ()) {
if (this->m_cur_step != this->cur_step) {
this->m_cur_step = this->cur_step;
2023-08-12 07:11:42 -06:00
if (this->m_cur_step == 1)
2023-08-11 00:14:05 -06:00
reset_texpos();
}
INTERPOSE_NEXT(logic)();
}
private:
inline static int m_cur_step = -2; // not valid state at the start
};
IMPLEMENT_VMETHOD_INTERPOSE(tracking_stage_load_region, logic);
// reset point on New Arena
struct tracking_stage_new_arena : df::viewscreen_new_arenast {
typedef df::viewscreen_new_arenast interpose_base;
DEFINE_VMETHOD_INTERPOSE(void, logic, ()) {
if (this->m_cur_step != this->cur_step) {
this->m_cur_step = this->cur_step;
if (this->m_cur_step == 0)
reset_texpos();
}
INTERPOSE_NEXT(logic)();
}
private:
inline static int m_cur_step = -2; // not valid state at the start
};
IMPLEMENT_VMETHOD_INTERPOSE(tracking_stage_new_arena, logic);
2023-08-11 12:40:41 -06:00
static void install_reset_point() {
2023-08-11 00:14:05 -06:00
INTERPOSE_HOOK(tracking_stage_new_region, logic).apply();
INTERPOSE_HOOK(tracking_stage_adopt_region, logic).apply();
INTERPOSE_HOOK(tracking_stage_load_region, logic).apply();
INTERPOSE_HOOK(tracking_stage_new_arena, logic).apply();
}
static void uninstall_reset_point() {
INTERPOSE_HOOK(tracking_stage_new_region, logic).remove();
INTERPOSE_HOOK(tracking_stage_adopt_region, logic).remove();
INTERPOSE_HOOK(tracking_stage_load_region, logic).remove();
INTERPOSE_HOOK(tracking_stage_new_arena, logic).remove();
}
2023-08-12 07:11:42 -06:00
void Textures::init(color_ostream& out) {
install_reset_point();
DEBUG(textures, out).print("dynamic texture loading ready");
}
void Textures::cleanup() {
2023-08-11 12:40:41 -06:00
reset_texpos();
reset_surface();
uninstall_reset_point();
2023-08-11 00:48:03 -06:00
}