add Textures module and load DFHack logo

undocumented for now since it's internal. in the future, perhaps this
could morph into a dynamic texture loading facility for tools
develop
Myk Taylor 2023-01-03 01:01:30 -08:00
parent a0343b06a6
commit 5d04b9c4cb
No known key found for this signature in database
GPG Key ID: 8A39CA0FA0C16E78
9 changed files with 296 additions and 8 deletions

@ -10,6 +10,9 @@ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/quickfort/
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/orders/ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/orders/
DESTINATION dfhack-config/orders/library) DESTINATION dfhack-config/orders/library)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/art/
DESTINATION "${DFHACK_DATA_DESTINATION}/data/art")
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/examples/ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/examples/
DESTINATION "${DFHACK_DATA_DESTINATION}/examples") DESTINATION "${DFHACK_DATA_DESTINATION}/examples")

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.4 KiB

@ -40,6 +40,7 @@ changelog.txt uses a syntax similar to RST, with a few special sequences:
## Misc Improvements ## Misc Improvements
- Scrollable widgets now react to mouse wheel events when the mouse is over the widget - Scrollable widgets now react to mouse wheel events when the mouse is over the widget
- the ``dfhack-config/scripts/`` folder is now searched for scripts by default - the ``dfhack-config/scripts/`` folder is now searched for scripts by default
- `hotkeys`: overlay hotspot widget now shows the DFHack logo in graphics mode and "DFHack" in text mode
## Documentation ## Documentation
- `overlay-dev-guide`: added troubleshooting tips and common development workflows - `overlay-dev-guide`: added troubleshooting tips and common development workflows

@ -141,6 +141,7 @@ set(MODULE_HEADERS
include/modules/Random.h include/modules/Random.h
include/modules/Renderer.h include/modules/Renderer.h
include/modules/Screen.h include/modules/Screen.h
include/modules/Textures.h
include/modules/Translation.h include/modules/Translation.h
include/modules/Units.h include/modules/Units.h
include/modules/World.h include/modules/World.h
@ -166,6 +167,7 @@ set(MODULE_SOURCES
modules/Random.cpp modules/Random.cpp
modules/Renderer.cpp modules/Renderer.cpp
modules/Screen.cpp modules/Screen.cpp
modules/Textures.cpp
modules/Translation.cpp modules/Translation.cpp
modules/Units.cpp modules/Units.cpp
modules/World.cpp modules/World.cpp

@ -52,6 +52,7 @@ using namespace std;
#include "modules/EventManager.h" #include "modules/EventManager.h"
#include "modules/Filesystem.h" #include "modules/Filesystem.h"
#include "modules/Gui.h" #include "modules/Gui.h"
#include "modules/Textures.h"
#include "modules/World.h" #include "modules/World.h"
#include "modules/Persistence.h" #include "modules/Persistence.h"
#include "RemoteServer.h" #include "RemoteServer.h"
@ -1670,8 +1671,10 @@ bool Core::Init()
return false; return false;
} }
cerr << "Initializing textures.\n";
Textures::init(con);
// create mutex for syncing with interactive tasks // create mutex for syncing with interactive tasks
cerr << "Initializing Plugins.\n"; cerr << "Initializing plugins.\n";
// create plugin manager // create plugin manager
plug_mgr = new PluginManager(this); plug_mgr = new PluginManager(this);
plug_mgr->init(); plug_mgr->init();
@ -1765,12 +1768,7 @@ bool Core::Init()
cerr << "DFHack is running.\n"; cerr << "DFHack is running.\n";
{ onStateChange(con, SC_CORE_INITIALIZED);
auto L = Lua::Core::State;
Lua::StackUnwinder top(L);
Lua::CallLuaModuleFunction(con, L, "script-manager", "reload");
onStateChange(con, SC_CORE_INITIALIZED);
}
return true; return true;
} }
@ -2138,6 +2136,13 @@ void Core::onStateChange(color_ostream &out, state_change_event event)
switch (event) switch (event)
{ {
case SC_CORE_INITIALIZED:
{
auto L = Lua::Core::State;
Lua::StackUnwinder top(L);
Lua::CallLuaModuleFunction(con, L, "script-manager", "reload");
}
break;
case SC_WORLD_LOADED: case SC_WORLD_LOADED:
case SC_WORLD_UNLOADED: case SC_WORLD_UNLOADED:
case SC_MAP_LOADED: case SC_MAP_LOADED:
@ -2171,6 +2176,10 @@ void Core::onStateChange(color_ostream &out, state_change_event event)
evtlog << std::endl; evtlog << std::endl;
} }
} }
break;
case SC_VIEWSCREEN_CHANGED:
Textures::init(out);
break;
default: default:
break; break;
} }
@ -2248,6 +2257,7 @@ int Core::Shutdown ( void )
} }
// invalidate all modules // invalidate all modules
allModules.clear(); allModules.clear();
Textures::cleanup();
memset(&(s_mods), 0, sizeof(s_mods)); memset(&(s_mods), 0, sizeof(s_mods));
d.reset(); d.reset();
return -1; return -1;

@ -57,6 +57,7 @@ distribution.
#include "modules/Materials.h" #include "modules/Materials.h"
#include "modules/Random.h" #include "modules/Random.h"
#include "modules/Screen.h" #include "modules/Screen.h"
#include "modules/Textures.h"
#include "modules/Translation.h" #include "modules/Translation.h"
#include "modules/Units.h" #include "modules/Units.h"
#include "modules/World.h" #include "modules/World.h"
@ -1670,6 +1671,13 @@ static const luaL_Reg dfhack_job_funcs[] = {
{ NULL, NULL } { NULL, NULL }
}; };
/***** Textures module *****/
static const LuaWrapper::FunctionReg dfhack_textures_module[] = {
WRAPM(Textures, getDfhackLogoTexposStart),
{ NULL, NULL }
};
/***** Units module *****/ /***** Units module *****/
static const LuaWrapper::FunctionReg dfhack_units_module[] = { static const LuaWrapper::FunctionReg dfhack_units_module[] = {
@ -3357,6 +3365,7 @@ void OpenDFHackApi(lua_State *state)
luaL_setfuncs(state, dfhack_funcs, 0); luaL_setfuncs(state, dfhack_funcs, 0);
OpenModule(state, "gui", dfhack_gui_module, dfhack_gui_funcs); OpenModule(state, "gui", dfhack_gui_module, dfhack_gui_funcs);
OpenModule(state, "job", dfhack_job_module, dfhack_job_funcs); OpenModule(state, "job", dfhack_job_module, dfhack_job_funcs);
OpenModule(state, "textures", dfhack_textures_module);
OpenModule(state, "units", dfhack_units_module, dfhack_units_funcs); OpenModule(state, "units", dfhack_units_module, dfhack_units_funcs);
OpenModule(state, "items", dfhack_items_module, dfhack_items_funcs); OpenModule(state, "items", dfhack_items_module, dfhack_items_funcs);
OpenModule(state, "maps", dfhack_maps_module, dfhack_maps_funcs); OpenModule(state, "maps", dfhack_maps_module, dfhack_maps_funcs);

@ -45,9 +45,29 @@ namespace DFHack
uint16_t w, h; uint16_t w, h;
} DFSDL_Rect; } DFSDL_Rect;
typedef struct typedef struct
{
void *palette; // SDL_Palette*
uint8_t BitsPerPixel;
uint8_t BytesPerPixel;
uint8_t Rloss;
uint8_t Gloss;
uint8_t Bloss;
uint8_t Aloss;
uint8_t Rshift;
uint8_t Gshift;
uint8_t Bshift;
uint8_t Ashift;
uint32_t Rmask;
uint32_t Gmask;
uint32_t Bmask;
uint32_t Amask;
uint32_t colorkey;
uint8_t alpha;
} DFSDL_PixelFormat;
typedef struct
{ {
uint32_t flags; uint32_t flags;
void* format; // PixelFormat* DFSDL_PixelFormat* format;
int w, h; int w, h;
int pitch; int pitch;
void* pixels; void* pixels;

@ -0,0 +1,35 @@
#pragma once
#include "Export.h"
#include "ColorText.h"
namespace DFHack {
/**
* The Textures module - loads and provides access to DFHack textures
* \ingroup grp_modules
* \ingroup grp_textures
*/
namespace Textures {
/**
* Call this on DFHack init and on every viewscreen change so we can reload
* and reindex textures as needed.
*/
void init(DFHack::color_ostream &out);
/**
* Call this when DFHack is being unloaded.
*
*/
void cleanup();
/**
* Get first texpos for the DFHack logo. This texpos and the next 11 make up the
* 4x3 grid of logo textures that can be displayed on the UI layer.
*/
DFHACK_EXPORT long getDfhackLogoTexposStart();
}
}

@ -0,0 +1,208 @@
#include "Internal.h"
#include "modules/Textures.h"
#include "Debug.h"
#include "PluginManager.h"
#include "df/enabler.h"
using df::global::enabler;
using namespace DFHack;
namespace DFHack {
DBG_DECLARE(core, textures, DebugCategory::LINFO);
}
static bool g_loaded = false;
static long g_num_dfhack_textures = 0;
static long g_dfhack_logo_texpos_start = -1;
static DFLibrary *g_sdl_handle = nullptr;
static DFLibrary *g_sdl_image_handle = nullptr;
static const std::vector<std::string> SDL_LIBS {
"SDLreal.dll",
"SDL.framework/Versions/A/SDL",
"SDL.framework/SDL",
"libSDL-1.2.so.0"
};
static const std::vector<std::string> SDL_IMAGE_LIBS {
"SDL_image.dll",
"SDL_image.framework/Versions/A/SDL_image",
"SDL_image.framework/SDL_image",
"libSDL_image-1.2.so.0"
};
DFSDL_Surface * (*g_IMG_Load)(const char *) = nullptr;
int (*g_SDL_SetAlpha)(DFSDL_Surface *, uint32_t, uint8_t) = nullptr;
DFSDL_Surface * (*g_SDL_CreateRGBSurface)(uint32_t, int, int, int, uint32_t, uint32_t, uint32_t, uint32_t);
int (*g_SDL_UpperBlit)(DFSDL_Surface *, DFSDL_Rect *, DFSDL_Surface *, DFSDL_Rect *);
DFSDL_Surface * (*g_SDL_ConvertSurface)(DFSDL_Surface *, const DFSDL_PixelFormat *, uint32_t);
void (*g_SDL_FreeSurface)(DFSDL_Surface *);
// 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.
DFSDL_Surface * canonicalize_format(DFSDL_Surface *src) {
DFSDL_PixelFormat fmt;
fmt.palette = NULL;
fmt.BitsPerPixel = 32;
fmt.BytesPerPixel = 4;
fmt.Rloss = fmt.Gloss = fmt.Bloss = fmt.Aloss = 0;
//#if SDL_BYTEORDER == SDL_BIG_ENDIAN
// fmt.Rshift = 24; fmt.Gshift = 16; fmt.Bshift = 8; fmt.Ashift = 0;
//#else
fmt.Rshift = 0; fmt.Gshift = 8; fmt.Bshift = 16; fmt.Ashift = 24;
//#endif
fmt.Rmask = 255 << fmt.Rshift;
fmt.Gmask = 255 << fmt.Gshift;
fmt.Bmask = 255 << fmt.Bshift;
fmt.Amask = 255 << fmt.Ashift;
fmt.colorkey = 0;
fmt.alpha = 255;
DFSDL_Surface *tgt = g_SDL_ConvertSurface(src, &fmt, 0); // SDL_SWSURFACE
g_SDL_FreeSurface(src);
return tgt;
}
const uint32_t TILE_WIDTH_PX = 8;
const uint32_t TILE_HEIGHT_PX = 12;
static size_t load_textures(color_ostream & out, const char * fname,
long *texpos_start) {
if (!g_sdl_handle || !g_sdl_image_handle || !g_IMG_Load || !g_SDL_SetAlpha
|| !g_SDL_CreateRGBSurface || !g_SDL_UpperBlit
|| !g_SDL_ConvertSurface || !g_SDL_FreeSurface)
return 0;
DFSDL_Surface *s = g_IMG_Load(fname);
if (!s) {
out.printerr("unable to load textures from '%s'\n", fname);
return 0;
}
s = canonicalize_format(s);
g_SDL_SetAlpha(s, 0, 255);
int dimx = s->w / TILE_WIDTH_PX;
int dimy = s->h / TILE_HEIGHT_PX;
long count = 0;
for (int y = 0; y < dimy; y++) {
for (int x = 0; x < dimx; x++) {
DFSDL_Surface *tile = g_SDL_CreateRGBSurface(0, // SDL_SWSURFACE
TILE_WIDTH_PX, TILE_HEIGHT_PX, 32,
s->format->Rmask, s->format->Gmask, s->format->Bmask,
s->format->Amask);
g_SDL_SetAlpha(tile, 0,255);
DFSDL_Rect vp;
vp.x = TILE_WIDTH_PX * x;
vp.y = TILE_HEIGHT_PX * y;
vp.w = TILE_WIDTH_PX;
vp.h = TILE_HEIGHT_PX;
g_SDL_UpperBlit(s, &vp, tile, NULL);
if (!count++)
*texpos_start = enabler->textures.raws.size();
enabler->textures.raws.push_back(tile);
}
}
g_SDL_FreeSurface(s);
DEBUG(textures,out).print("loaded %zd textures from '%s'\n", count, fname);
return count;
}
// DFHack could conceivably be loaded at any time, so we need to be able to
// handle loading textures before or after a world is loaded.
// If a world is already loaded, then append our textures to the raws. they'll
// be freed when the world is unloaded and we'll reload when we get to the title
// screen. If it's pre-world, append our textures and then adjust the "init"
// texture count so our textures will no longer be freed when worlds are
// unloaded.
//
void Textures::init(color_ostream &out) {
auto & textures = enabler->textures;
long num_textures = textures.raws.size();
if (num_textures <= g_dfhack_logo_texpos_start)
g_loaded = false;
if (g_loaded)
return;
for (auto &lib_str : SDL_LIBS) {
if ((g_sdl_handle = OpenPlugin(lib_str.c_str())))
break;
}
for (auto &lib_str : SDL_IMAGE_LIBS) {
if ((g_sdl_image_handle = OpenPlugin(lib_str.c_str())))
break;
}
if (!g_sdl_handle) {
out.printerr("Could not find SDL; DFHack textures not loaded.\n");
} else if (!g_sdl_image_handle) {
out.printerr("Could not find SDL_image; DFHack textures not loaded.\n");
} else {
#define bind(handle, name) \
g_##name = (decltype(g_##name))LookupPlugin(handle, #name); \
if (!g_##name) { \
out.printerr("Could not find: " #name "; DFHack textures not loaded\n"); \
}
bind(g_sdl_image_handle, IMG_Load);
bind(g_sdl_handle, SDL_SetAlpha);
bind(g_sdl_handle, SDL_CreateRGBSurface);
bind(g_sdl_handle, SDL_UpperBlit);
bind(g_sdl_handle, SDL_ConvertSurface);
bind(g_sdl_handle, SDL_FreeSurface);
#undef bind
}
bool is_pre_world = num_textures == textures.init_texture_size;
g_num_dfhack_textures = load_textures(out, "hack/data/art/dfhack.png",
&g_dfhack_logo_texpos_start);
DEBUG(textures,out).print("loaded %zd textures\n", g_num_dfhack_textures);
if (is_pre_world)
textures.init_texture_size += g_num_dfhack_textures;
// NOTE: when GL modes are supported, we'll have to re-upload textures here
g_loaded = true;
}
// It's ok to leave NULLs in the raws list (according to usage in g_src)
void Textures::cleanup() {
if (!g_loaded)
return;
auto & textures = enabler->textures;
auto &raws = textures.raws;
size_t texpos_end = g_dfhack_logo_texpos_start + g_num_dfhack_textures;
for (size_t idx = g_dfhack_logo_texpos_start; idx <= texpos_end; ++idx) {
SDL_FreeSurface(raws[idx]);
raws[idx] = NULL;
}
if (g_dfhack_logo_texpos_start == textures.init_texture_size - g_num_dfhack_textures)
textures.init_texture_size -= g_num_dfhack_textures;
g_loaded = false;
g_num_dfhack_textures = 0;
g_dfhack_logo_texpos_start = -1;
if (g_sdl_handle) {
ClosePlugin(g_sdl_handle);
g_sdl_handle = nullptr;
}
}
long Textures::getDfhackLogoTexposStart() {
return g_dfhack_logo_texpos_start;
}