minetestmapper/mapper.cpp

275 lines
6.3 KiB
C++
Raw Normal View History

2020-03-28 14:02:27 +01:00
#include <cstdio>
2012-08-22 15:49:45 +02:00
#include <cstdlib>
#include <cstring>
2012-08-23 12:30:09 +02:00
#include <getopt.h>
#include <fstream>
2012-08-22 15:49:45 +02:00
#include <iostream>
2020-03-28 14:02:27 +01:00
#include <utility>
2012-08-22 16:04:43 +02:00
#include <string>
2012-11-24 19:25:13 +01:00
#include <sstream>
2014-03-09 12:32:13 +01:00
#include <stdexcept>
#include "config.h"
2012-08-23 12:46:22 +02:00
#include "TileGenerator.h"
2012-08-22 15:49:45 +02:00
2020-03-26 23:07:27 +01:00
static void usage()
2012-08-22 15:49:45 +02:00
{
2020-03-28 14:02:27 +01:00
const std::pair<const char*, const char*> options[] = {
{"-i/--input", "<world_path>"},
{"-o/--output", "<output_image.png>"},
{"--bgcolor", "<color>"},
{"--scalecolor", "<color>"},
{"--playercolor", "<color>"},
{"--origincolor", "<color>"},
{"--drawscale", ""},
{"--drawplayers", ""},
{"--draworigin", ""},
{"--drawalpha", ""},
{"--noshading", ""},
{"--noemptyimage", ""},
{"--min-y", "<y>"},
{"--max-y", "<y>"},
{"--backend", "<backend>"},
{"--geometry", "x:y+w+h"},
{"--extent", ""},
{"--zoom", "<zoomlevel>"},
{"--colors", "<colors.txt>"},
{"--scales", "[t][b][l][r]"},
{"--exhaustive", "never|y|full|auto"},
{"--dumpblock", "x,y,z"},
2020-03-28 14:02:27 +01:00
};
const char *top_text =
"minetestmapper -i <world_path> -o <output_image.png> [options]\n"
2024-11-11 09:50:26 +01:00
"Generate an overview image of a Luanti map.\n"
2020-03-28 14:02:27 +01:00
"\n"
"Options:\n";
const char *bottom_text =
"\n"
"Color format: hexadecimal '#RRGGBB', e.g. '#FF0000' = red\n";
printf("%s", top_text);
for (const auto &p : options)
printf(" %-18s%s\n", p.first, p.second);
printf("%s", bottom_text);
auto backends = TileGenerator::getSupportedBackends();
printf("Supported backends: ");
for (auto s : backends)
printf("%s ", s.c_str());
printf("\n");
2012-08-22 15:49:45 +02:00
}
2022-02-09 22:46:07 +01:00
static inline bool file_exists(const std::string &path)
{
std::ifstream ifs(path);
return ifs.is_open();
}
2022-02-09 22:46:07 +01:00
static inline int stoi(const char *s)
{
std::istringstream iss(s);
int ret;
iss >> ret;
return ret;
}
2020-03-26 23:07:27 +01:00
static std::string search_colors(const std::string &worldpath)
{
2022-02-09 22:46:07 +01:00
if (file_exists(worldpath + "/colors.txt"))
return worldpath + "/colors.txt";
#ifndef _WIN32
char *home = std::getenv("HOME");
2022-02-09 22:46:07 +01:00
if (home) {
std::string check = std::string(home) + "/.minetest/colors.txt";
if (file_exists(check))
return check;
}
#endif
2020-03-26 23:07:27 +01:00
constexpr bool sharedir_valid = !(SHAREDIR[0] == '.' || SHAREDIR[0] == '\0');
2022-02-09 22:46:07 +01:00
if (sharedir_valid && file_exists(SHAREDIR "/colors.txt"))
return SHAREDIR "/colors.txt";
std::cerr << "Warning: Falling back to using colors.txt from current directory." << std::endl;
return "colors.txt";
}
2012-08-22 15:22:01 +02:00
int main(int argc, char *argv[])
{
2020-03-26 23:07:27 +01:00
const static struct option long_options[] =
2012-08-22 15:49:45 +02:00
{
{"help", no_argument, 0, 'h'},
{"input", required_argument, 0, 'i'},
{"output", required_argument, 0, 'o'},
{"bgcolor", required_argument, 0, 'b'},
{"scalecolor", required_argument, 0, 's'},
{"origincolor", required_argument, 0, 'r'},
{"playercolor", required_argument, 0, 'p'},
2012-08-22 16:04:43 +02:00
{"draworigin", no_argument, 0, 'R'},
{"drawplayers", no_argument, 0, 'P'},
{"drawscale", no_argument, 0, 'S'},
{"drawalpha", no_argument, 0, 'e'},
{"noshading", no_argument, 0, 'H'},
{"backend", required_argument, 0, 'd'},
2012-11-24 19:25:13 +01:00
{"geometry", required_argument, 0, 'g'},
{"extent", no_argument, 0, 'E'},
2014-03-05 18:06:05 +01:00
{"min-y", required_argument, 0, 'a'},
2016-07-06 21:45:38 +02:00
{"max-y", required_argument, 0, 'c'},
{"zoom", required_argument, 0, 'z'},
{"colors", required_argument, 0, 'C'},
{"scales", required_argument, 0, 'f'},
{"noemptyimage", no_argument, 0, 'n'},
{"exhaustive", required_argument, 0, 'j'},
{"dumpblock", required_argument, 0, 'k'},
{0, 0, 0, 0}
2012-08-22 15:49:45 +02:00
};
2012-08-23 12:46:22 +02:00
std::string input;
std::string output;
std::string colors;
bool onlyPrintExtent = false;
BlockPos dumpblock(INT16_MIN);
2012-08-22 16:04:43 +02:00
2012-08-23 12:46:22 +02:00
TileGenerator generator;
2012-08-22 15:49:45 +02:00
while (1) {
int option_index;
int c = getopt_long(argc, argv, "hi:o:", long_options, &option_index);
if (c == -1)
break; // done
2012-08-22 16:04:43 +02:00
switch (c) {
case 'h':
usage();
return 0;
2012-08-22 16:04:43 +02:00
case 'i':
input = optarg;
break;
case 'o':
output = optarg;
break;
case 'b':
2012-08-23 12:46:22 +02:00
generator.setBgColor(optarg);
2012-08-22 16:04:43 +02:00
break;
case 's':
2012-08-23 12:46:22 +02:00
generator.setScaleColor(optarg);
2012-08-22 16:04:43 +02:00
break;
case 'r':
2012-08-23 12:46:22 +02:00
generator.setOriginColor(optarg);
2012-08-22 16:04:43 +02:00
break;
case 'p':
2012-08-23 12:46:22 +02:00
generator.setPlayerColor(optarg);
2012-08-22 16:04:43 +02:00
break;
case 'R':
2012-08-23 12:46:22 +02:00
generator.setDrawOrigin(true);
2012-08-22 16:04:43 +02:00
break;
case 'P':
2012-08-23 12:46:22 +02:00
generator.setDrawPlayers(true);
2012-08-22 16:04:43 +02:00
break;
case 'S':
2012-08-23 12:46:22 +02:00
generator.setDrawScale(true);
2012-08-22 16:04:43 +02:00
break;
case 'e':
generator.setDrawAlpha(true);
break;
case 'E':
onlyPrintExtent = true;
break;
case 'H':
generator.setShading(false);
break;
case 'd':
generator.setBackend(optarg);
break;
2022-02-09 22:46:07 +01:00
case 'a':
generator.setMinY(stoi(optarg));
2014-03-05 18:06:05 +01:00
break;
2022-02-09 22:46:07 +01:00
case 'c':
generator.setMaxY(stoi(optarg));
2014-03-05 18:06:05 +01:00
break;
2012-11-24 19:25:13 +01:00
case 'g': {
2018-10-20 23:01:03 +02:00
std::istringstream geometry(optarg);
2012-11-24 19:25:13 +01:00
int x, y, w, h;
char c;
geometry >> x >> c >> y >> w >> h;
if (geometry.fail() || c != ':' || w < 1 || h < 1) {
usage();
2014-03-05 18:06:05 +01:00
exit(1);
2012-11-24 19:25:13 +01:00
}
generator.setGeometry(x, y, w, h);
}
break;
case 'f': {
uint flags = 0;
2022-02-09 22:46:07 +01:00
if (strchr(optarg, 't'))
flags |= SCALE_TOP;
2022-02-09 22:46:07 +01:00
if (strchr(optarg, 'b'))
flags |= SCALE_BOTTOM;
2022-02-09 22:46:07 +01:00
if (strchr(optarg, 'l'))
flags |= SCALE_LEFT;
2022-02-09 22:46:07 +01:00
if (strchr(optarg, 'r'))
flags |= SCALE_RIGHT;
generator.setScales(flags);
}
break;
2022-02-09 22:46:07 +01:00
case 'z':
generator.setZoom(stoi(optarg));
2016-07-06 21:45:38 +02:00
break;
case 'C':
colors = optarg;
break;
case 'n':
generator.setDontWriteEmpty(true);
break;
case 'j': {
2022-02-09 22:46:07 +01:00
int mode = EXH_AUTO;;
if (!strcmp(optarg, "never"))
mode = EXH_NEVER;
else if (!strcmp(optarg, "y"))
mode = EXH_Y;
else if (!strcmp(optarg, "full"))
mode = EXH_FULL;
generator.setExhaustiveSearch(mode);
}
break;
case 'k': {
std::istringstream iss(optarg);
char c, c2;
iss >> dumpblock.x >> c >> dumpblock.y >> c2 >> dumpblock.z;
if (iss.fail() || c != ',' || c2 != ',') {
usage();
exit(1);
}
break;
}
2012-08-22 16:04:43 +02:00
default:
2014-03-05 18:06:05 +01:00
exit(1);
2012-08-22 16:04:43 +02:00
}
2012-08-22 15:49:45 +02:00
}
const bool need_output = !onlyPrintExtent && dumpblock.x == INT16_MIN;
if (input.empty() || (need_output && output.empty())) {
usage();
return 0;
}
try {
if (onlyPrintExtent) {
generator.printGeometry(input);
return 0;
} else if (dumpblock.x != INT16_MIN) {
generator.dumpBlock(input, dumpblock);
return 0;
}
2022-02-09 22:46:07 +01:00
if(colors.empty())
colors = search_colors(input);
generator.parseColorsFile(colors);
generator.generate(input, output);
} catch (const std::exception &e) {
std::cerr << "Exception: " << e.what() << std::endl;
return 1;
}
return 0;
2012-08-22 15:22:01 +02:00
}