00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "fileio_func.h"
00014 #include "viewport_func.h"
00015 #include "gfx_func.h"
00016 #include "screenshot.h"
00017 #include "blitter/factory.hpp"
00018 #include "zoom_func.h"
00019 #include "core/endian_func.hpp"
00020 #include "saveload/saveload.h"
00021 #include "company_func.h"
00022 #include "strings_func.h"
00023 #include "gui.h"
00024 #include "window_gui.h"
00025 #include "window_func.h"
00026 #include "tile_map.h"
00027
00028 #include "table/strings.h"
00029
00030 static const char * const SCREENSHOT_NAME = "screenshot";
00031 static const char * const HEIGHTMAP_NAME = "heightmap";
00032
00033 char _screenshot_format_name[8];
00034 uint _num_screenshot_formats;
00035 uint _cur_screenshot_format;
00036 static char _screenshot_name[128];
00037 char _full_screenshot_name[MAX_PATH];
00038
00047 typedef void ScreenshotCallback(void *userdata, void *buf, uint y, uint pitch, uint n);
00048
00060 typedef bool ScreenshotHandlerProc(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette);
00061
00063 struct ScreenshotFormat {
00064 const char *name;
00065 const char *extension;
00066 ScreenshotHandlerProc *proc;
00067 };
00068
00069
00070
00071
00072 #if defined(_MSC_VER) || defined(__WATCOMC__)
00073 #pragma pack(push, 1)
00074 #endif
00075
00077 struct BitmapFileHeader {
00078 uint16 type;
00079 uint32 size;
00080 uint32 reserved;
00081 uint32 off_bits;
00082 } GCC_PACK;
00083 assert_compile(sizeof(BitmapFileHeader) == 14);
00084
00085 #if defined(_MSC_VER) || defined(__WATCOMC__)
00086 #pragma pack(pop)
00087 #endif
00088
00090 struct BitmapInfoHeader {
00091 uint32 size;
00092 int32 width, height;
00093 uint16 planes, bitcount;
00094 uint32 compression, sizeimage, xpels, ypels, clrused, clrimp;
00095 };
00096 assert_compile(sizeof(BitmapInfoHeader) == 40);
00097
00099 struct RgbQuad {
00100 byte blue, green, red, reserved;
00101 };
00102 assert_compile(sizeof(RgbQuad) == 4);
00103
00116 static bool MakeBMPImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
00117 {
00118 uint bpp;
00119 switch (pixelformat) {
00120 case 8: bpp = 1; break;
00121
00122 case 32: bpp = 3; break;
00123
00124 default: return false;
00125 }
00126
00127 FILE *f = fopen(name, "wb");
00128 if (f == NULL) return false;
00129
00130
00131 uint bytewidth = Align(w * bpp, 4);
00132
00133
00134 uint pal_size = pixelformat == 8 ? sizeof(RgbQuad) * 256 : 0;
00135
00136
00137 BitmapFileHeader bfh;
00138 bfh.type = TO_LE16('MB');
00139 bfh.size = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size + bytewidth * h);
00140 bfh.reserved = 0;
00141 bfh.off_bits = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size);
00142
00143
00144 BitmapInfoHeader bih;
00145 bih.size = TO_LE32(sizeof(BitmapInfoHeader));
00146 bih.width = TO_LE32(w);
00147 bih.height = TO_LE32(h);
00148 bih.planes = TO_LE16(1);
00149 bih.bitcount = TO_LE16(bpp * 8);
00150 bih.compression = 0;
00151 bih.sizeimage = 0;
00152 bih.xpels = 0;
00153 bih.ypels = 0;
00154 bih.clrused = 0;
00155 bih.clrimp = 0;
00156
00157
00158 if (fwrite(&bfh, sizeof(bfh), 1, f) != 1 || fwrite(&bih, sizeof(bih), 1, f) != 1) {
00159 fclose(f);
00160 return false;
00161 }
00162
00163 if (pixelformat == 8) {
00164
00165 RgbQuad rq[256];
00166 for (uint i = 0; i < 256; i++) {
00167 rq[i].red = palette[i].r;
00168 rq[i].green = palette[i].g;
00169 rq[i].blue = palette[i].b;
00170 rq[i].reserved = 0;
00171 }
00172
00173 if (fwrite(rq, sizeof(rq), 1, f) != 1) {
00174 fclose(f);
00175 return false;
00176 }
00177 }
00178
00179
00180 uint maxlines = Clamp(65536 / (w * pixelformat / 8), 16, 128);
00181
00182 uint8 *buff = MallocT<uint8>(maxlines * w * pixelformat / 8);
00183 uint8 *line = AllocaM(uint8, bytewidth);
00184 memset(line, 0, bytewidth);
00185
00186
00187 do {
00188 uint n = min(h, maxlines);
00189 h -= n;
00190
00191
00192 callb(userdata, buff, h, w, n);
00193
00194
00195 while (n-- != 0) {
00196 if (pixelformat == 8) {
00197
00198 memcpy(line, buff + n * w, w);
00199 } else {
00200
00201
00202 Colour *src = ((Colour *)buff) + n * w;
00203 byte *dst = line;
00204 for (uint i = 0; i < w; i++) {
00205 dst[i * 3 ] = src[i].b;
00206 dst[i * 3 + 1] = src[i].g;
00207 dst[i * 3 + 2] = src[i].r;
00208 }
00209 }
00210
00211 if (fwrite(line, bytewidth, 1, f) != 1) {
00212 free(buff);
00213 fclose(f);
00214 return false;
00215 }
00216 }
00217 } while (h != 0);
00218
00219 free(buff);
00220 fclose(f);
00221
00222 return true;
00223 }
00224
00225
00226
00227
00228 #if defined(WITH_PNG)
00229 #include <png.h>
00230
00231 #ifdef PNG_TEXT_SUPPORTED
00232 #include "rev.h"
00233 #include "newgrf_config.h"
00234 #include "ai/ai_info.hpp"
00235 #include "company_base.h"
00236 #include "base_media_base.h"
00237 #endif
00238
00239 static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)
00240 {
00241 DEBUG(misc, 0, "[libpng] error: %s - %s", message, (const char *)png_get_error_ptr(png_ptr));
00242 longjmp(png_jmpbuf(png_ptr), 1);
00243 }
00244
00245 static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)
00246 {
00247 DEBUG(misc, 1, "[libpng] warning: %s - %s", message, (const char *)png_get_error_ptr(png_ptr));
00248 }
00249
00262 static bool MakePNGImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
00263 {
00264 png_color rq[256];
00265 FILE *f;
00266 uint i, y, n;
00267 uint maxlines;
00268 uint bpp = pixelformat / 8;
00269 png_structp png_ptr;
00270 png_infop info_ptr;
00271
00272
00273 if (pixelformat != 8 && pixelformat != 32) return false;
00274
00275 f = fopen(name, "wb");
00276 if (f == NULL) return false;
00277
00278 png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (void *)name, png_my_error, png_my_warning);
00279
00280 if (png_ptr == NULL) {
00281 fclose(f);
00282 return false;
00283 }
00284
00285 info_ptr = png_create_info_struct(png_ptr);
00286 if (info_ptr == NULL) {
00287 png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
00288 fclose(f);
00289 return false;
00290 }
00291
00292 if (setjmp(png_jmpbuf(png_ptr))) {
00293 png_destroy_write_struct(&png_ptr, &info_ptr);
00294 fclose(f);
00295 return false;
00296 }
00297
00298 png_init_io(png_ptr, f);
00299
00300 png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
00301
00302 png_set_IHDR(png_ptr, info_ptr, w, h, 8, pixelformat == 8 ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_RGB,
00303 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
00304
00305 #ifdef PNG_TEXT_SUPPORTED
00306
00307
00308 png_text_struct text[2];
00309 memset(text, 0, sizeof(text));
00310 text[0].key = const_cast<char *>("Software");
00311 text[0].text = const_cast<char *>(_openttd_revision);
00312 text[0].text_length = strlen(_openttd_revision);
00313 text[0].compression = PNG_TEXT_COMPRESSION_NONE;
00314
00315 char buf[8192];
00316 char *p = buf;
00317 p += seprintf(p, lastof(buf), "Graphics set: %s (%u)\n", BaseGraphics::GetUsedSet()->name, BaseGraphics::GetUsedSet()->version);
00318 p = strecpy(p, "NewGRFs:\n", lastof(buf));
00319 for (const GRFConfig *c = _game_mode == GM_MENU ? NULL : _grfconfig; c != NULL; c = c->next) {
00320 p += seprintf(p, lastof(buf), "%08X ", BSWAP32(c->ident.grfid));
00321 p = md5sumToString(p, lastof(buf), c->ident.md5sum);
00322 p += seprintf(p, lastof(buf), " %s\n", c->filename);
00323 }
00324 p = strecpy(p, "\nCompanies:\n", lastof(buf));
00325 const Company *c;
00326 FOR_ALL_COMPANIES(c) {
00327 if (c->ai_info == NULL) {
00328 p += seprintf(p, lastof(buf), "%2i: Human\n", (int)c->index);
00329 } else {
00330 #ifdef ENABLE_AI
00331 p += seprintf(p, lastof(buf), "%2i: %s (v%d)\n", (int)c->index, c->ai_info->GetName(), c->ai_info->GetVersion());
00332 #endif
00333 }
00334 }
00335 text[1].key = const_cast<char *>("Description");
00336 text[1].text = buf;
00337 text[1].text_length = p - buf;
00338 text[1].compression = PNG_TEXT_COMPRESSION_zTXt;
00339 png_set_text(png_ptr, info_ptr, text, 2);
00340 #endif
00341
00342 if (pixelformat == 8) {
00343
00344 for (i = 0; i != 256; i++) {
00345 rq[i].red = palette[i].r;
00346 rq[i].green = palette[i].g;
00347 rq[i].blue = palette[i].b;
00348 }
00349
00350 png_set_PLTE(png_ptr, info_ptr, rq, 256);
00351 }
00352
00353 png_write_info(png_ptr, info_ptr);
00354 png_set_flush(png_ptr, 512);
00355
00356 if (pixelformat == 32) {
00357 png_color_8 sig_bit;
00358
00359
00360 sig_bit.alpha = 0;
00361 sig_bit.blue = 8;
00362 sig_bit.green = 8;
00363 sig_bit.red = 8;
00364 sig_bit.gray = 8;
00365 png_set_sBIT(png_ptr, info_ptr, &sig_bit);
00366
00367 #if TTD_ENDIAN == TTD_LITTLE_ENDIAN
00368 png_set_bgr(png_ptr);
00369 png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
00370 #else
00371 png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
00372 #endif
00373 }
00374
00375
00376 maxlines = Clamp(65536 / w, 16, 128);
00377
00378
00379 void *buff = CallocT<uint8>(w * maxlines * bpp);
00380
00381 y = 0;
00382 do {
00383
00384 n = min(h - y, maxlines);
00385
00386
00387 callb(userdata, buff, y, w, n);
00388 y += n;
00389
00390
00391 for (i = 0; i != n; i++) {
00392 png_write_row(png_ptr, (png_bytep)buff + i * w * bpp);
00393 }
00394 } while (y != h);
00395
00396 png_write_end(png_ptr, info_ptr);
00397 png_destroy_write_struct(&png_ptr, &info_ptr);
00398
00399 free(buff);
00400 fclose(f);
00401 return true;
00402 }
00403 #endif
00404
00405
00406
00407
00408
00409
00411 struct PcxHeader {
00412 byte manufacturer;
00413 byte version;
00414 byte rle;
00415 byte bpp;
00416 uint32 unused;
00417 uint16 xmax, ymax;
00418 uint16 hdpi, vdpi;
00419 byte pal_small[16 * 3];
00420 byte reserved;
00421 byte planes;
00422 uint16 pitch;
00423 uint16 cpal;
00424 uint16 width;
00425 uint16 height;
00426 byte filler[54];
00427 };
00428 assert_compile(sizeof(PcxHeader) == 128);
00429
00442 static bool MakePCXImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
00443 {
00444 FILE *f;
00445 uint maxlines;
00446 uint y;
00447 PcxHeader pcx;
00448 bool success;
00449
00450 if (pixelformat == 32) {
00451 DEBUG(misc, 0, "Can't convert a 32bpp screenshot to PCX format. Please pick another format.");
00452 return false;
00453 }
00454 if (pixelformat != 8 || w == 0) return false;
00455
00456 f = fopen(name, "wb");
00457 if (f == NULL) return false;
00458
00459 memset(&pcx, 0, sizeof(pcx));
00460
00461
00462 pcx.manufacturer = 10;
00463 pcx.version = 5;
00464 pcx.rle = 1;
00465 pcx.bpp = 8;
00466 pcx.xmax = TO_LE16(w - 1);
00467 pcx.ymax = TO_LE16(h - 1);
00468 pcx.hdpi = TO_LE16(320);
00469 pcx.vdpi = TO_LE16(320);
00470
00471 pcx.planes = 1;
00472 pcx.cpal = TO_LE16(1);
00473 pcx.width = pcx.pitch = TO_LE16(w);
00474 pcx.height = TO_LE16(h);
00475
00476
00477 if (fwrite(&pcx, sizeof(pcx), 1, f) != 1) {
00478 fclose(f);
00479 return false;
00480 }
00481
00482
00483 maxlines = Clamp(65536 / w, 16, 128);
00484
00485
00486 uint8 *buff = CallocT<uint8>(w * maxlines);
00487
00488 y = 0;
00489 do {
00490
00491 uint n = min(h - y, maxlines);
00492 uint i;
00493
00494
00495 callb(userdata, buff, y, w, n);
00496 y += n;
00497
00498
00499 for (i = 0; i != n; i++) {
00500 const uint8 *bufp = buff + i * w;
00501 byte runchar = bufp[0];
00502 uint runcount = 1;
00503 uint j;
00504
00505
00506 for (j = 1; j < w; j++) {
00507 uint8 ch = bufp[j];
00508
00509 if (ch != runchar || runcount >= 0x3f) {
00510 if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
00511 if (fputc(0xC0 | runcount, f) == EOF) {
00512 free(buff);
00513 fclose(f);
00514 return false;
00515 }
00516 }
00517 if (fputc(runchar, f) == EOF) {
00518 free(buff);
00519 fclose(f);
00520 return false;
00521 }
00522 runcount = 0;
00523 runchar = ch;
00524 }
00525 runcount++;
00526 }
00527
00528
00529 if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
00530 if (fputc(0xC0 | runcount, f) == EOF) {
00531 free(buff);
00532 fclose(f);
00533 return false;
00534 }
00535 }
00536 if (fputc(runchar, f) == EOF) {
00537 free(buff);
00538 fclose(f);
00539 return false;
00540 }
00541 }
00542 } while (y != h);
00543
00544 free(buff);
00545
00546
00547 if (fputc(12, f) == EOF) {
00548 fclose(f);
00549 return false;
00550 }
00551
00552
00553 byte tmp[256 * 3];
00554
00555 for (uint i = 0; i < 256; i++) {
00556 tmp[i * 3 + 0] = palette[i].r;
00557 tmp[i * 3 + 1] = palette[i].g;
00558 tmp[i * 3 + 2] = palette[i].b;
00559 }
00560 success = fwrite(tmp, sizeof(tmp), 1, f) == 1;
00561
00562 fclose(f);
00563
00564 return success;
00565 }
00566
00567
00568
00569
00570
00572 static const ScreenshotFormat _screenshot_formats[] = {
00573 #if defined(WITH_PNG)
00574 {"PNG", "png", &MakePNGImage},
00575 #endif
00576 {"BMP", "bmp", &MakeBMPImage},
00577 {"PCX", "pcx", &MakePCXImage},
00578 };
00579
00581 const char *GetCurrentScreenshotExtension()
00582 {
00583 return _screenshot_formats[_cur_screenshot_format].extension;
00584 }
00585
00587 void InitializeScreenshotFormats()
00588 {
00589 uint j = 0;
00590 for (uint i = 0; i < lengthof(_screenshot_formats); i++) {
00591 if (!strcmp(_screenshot_format_name, _screenshot_formats[i].extension)) {
00592 j = i;
00593 break;
00594 }
00595 }
00596 _cur_screenshot_format = j;
00597 _num_screenshot_formats = lengthof(_screenshot_formats);
00598 }
00599
00605 const char *GetScreenshotFormatDesc(int i)
00606 {
00607 return _screenshot_formats[i].name;
00608 }
00609
00614 void SetScreenshotFormat(uint i)
00615 {
00616 assert(i < _num_screenshot_formats);
00617 _cur_screenshot_format = i;
00618 strecpy(_screenshot_format_name, _screenshot_formats[i].extension, lastof(_screenshot_format_name));
00619 }
00620
00625 static void CurrentScreenCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
00626 {
00627 Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
00628 void *src = blitter->MoveTo(_screen.dst_ptr, 0, y);
00629 blitter->CopyImageToBuffer(src, buf, _screen.width, n, pitch);
00630 }
00631
00640 static void LargeWorldCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
00641 {
00642 ViewPort *vp = (ViewPort *)userdata;
00643 DrawPixelInfo dpi, *old_dpi;
00644 int wx, left;
00645
00646
00647 DrawPixelInfo old_screen = _screen;
00648 bool old_disable_anim = _screen_disable_anim;
00649
00650 _screen.dst_ptr = buf;
00651 _screen.width = pitch;
00652 _screen.height = n;
00653 _screen.pitch = pitch;
00654 _screen_disable_anim = true;
00655
00656 old_dpi = _cur_dpi;
00657 _cur_dpi = &dpi;
00658
00659 dpi.dst_ptr = buf;
00660 dpi.height = n;
00661 dpi.width = vp->width;
00662 dpi.pitch = pitch;
00663 dpi.zoom = ZOOM_LVL_WORLD_SCREENSHOT;
00664 dpi.left = 0;
00665 dpi.top = y;
00666
00667
00668 left = 0;
00669 while (vp->width - left != 0) {
00670 wx = min(vp->width - left, 1600);
00671 left += wx;
00672
00673 ViewportDoDraw(vp,
00674 ScaleByZoom(left - wx - vp->left, vp->zoom) + vp->virtual_left,
00675 ScaleByZoom(y - vp->top, vp->zoom) + vp->virtual_top,
00676 ScaleByZoom(left - vp->left, vp->zoom) + vp->virtual_left,
00677 ScaleByZoom((y + n) - vp->top, vp->zoom) + vp->virtual_top
00678 );
00679 }
00680
00681 _cur_dpi = old_dpi;
00682
00683
00684 _screen = old_screen;
00685 _screen_disable_anim = old_disable_anim;
00686 }
00687
00694 static const char *MakeScreenshotName(const char *default_fn, const char *ext)
00695 {
00696 bool generate = StrEmpty(_screenshot_name);
00697
00698 if (generate) {
00699 if (_game_mode == GM_EDITOR || _game_mode == GM_MENU || _local_company == COMPANY_SPECTATOR) {
00700 strecpy(_screenshot_name, default_fn, lastof(_screenshot_name));
00701 } else {
00702 GenerateDefaultSaveName(_screenshot_name, lastof(_screenshot_name));
00703 }
00704 }
00705
00706
00707 size_t len = strlen(_screenshot_name);
00708 snprintf(&_screenshot_name[len], lengthof(_screenshot_name) - len, ".%s", ext);
00709
00710 for (uint serial = 1;; serial++) {
00711 if (snprintf(_full_screenshot_name, lengthof(_full_screenshot_name), "%s%s", _personal_dir, _screenshot_name) >= (int)lengthof(_full_screenshot_name)) {
00712
00713 _full_screenshot_name[0] = '\0';
00714 break;
00715 }
00716 if (!generate) break;
00717 if (!FileExists(_full_screenshot_name)) break;
00718
00719 snprintf(&_screenshot_name[len], lengthof(_screenshot_name) - len, "#%u.%s", serial, ext);
00720 }
00721
00722 return _full_screenshot_name;
00723 }
00724
00726 static bool MakeSmallScreenshot()
00727 {
00728 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00729 return sf->proc(MakeScreenshotName(SCREENSHOT_NAME, sf->extension), CurrentScreenCallback, NULL, _screen.width, _screen.height,
00730 BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth(), _cur_palette);
00731 }
00732
00734 static bool MakeZoomedInScreenshot()
00735 {
00736 Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
00737 ViewPort vp;
00738
00739 vp.zoom = ZOOM_LVL_WORLD_SCREENSHOT;
00740 vp.left = w->viewport->left;
00741 vp.top = w->viewport->top;
00742 vp.virtual_left = w->viewport->virtual_left;
00743 vp.virtual_top = w->viewport->virtual_top;
00744 vp.virtual_width = w->viewport->virtual_width;
00745 vp.width = vp.virtual_width;
00746 vp.virtual_height = w->viewport->virtual_height;
00747 vp.height = vp.virtual_height;
00748
00749 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00750 return sf->proc(MakeScreenshotName(SCREENSHOT_NAME, sf->extension), LargeWorldCallback, &vp, vp.width, vp.height,
00751 BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth(), _cur_palette);
00752 }
00753
00755 static bool MakeWorldScreenshot()
00756 {
00757 ViewPort vp;
00758 const ScreenshotFormat *sf;
00759
00760
00761 int extra_height_top = TileHeight(0) * TILE_HEIGHT + 150;
00762
00763 int reclaim_height_bottom = TileHeight(MapSize() - 1) * TILE_HEIGHT;
00764
00765 vp.zoom = ZOOM_LVL_WORLD_SCREENSHOT;
00766 vp.left = 0;
00767 vp.top = 0;
00768 vp.virtual_left = -(int)MapMaxX() * TILE_PIXELS;
00769 vp.virtual_top = -extra_height_top;
00770 vp.virtual_width = (MapMaxX() + MapMaxY()) * TILE_PIXELS;
00771 vp.width = vp.virtual_width;
00772 vp.virtual_height = ((MapMaxX() + MapMaxY()) * TILE_PIXELS >> 1) + extra_height_top - reclaim_height_bottom;
00773 vp.height = vp.virtual_height;
00774
00775 sf = _screenshot_formats + _cur_screenshot_format;
00776 return sf->proc(MakeScreenshotName(SCREENSHOT_NAME, sf->extension), LargeWorldCallback, &vp, vp.width, vp.height,
00777 BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth(), _cur_palette);
00778 }
00779
00789 static void HeightmapCallback(void *userdata, void *buffer, uint y, uint pitch, uint n)
00790 {
00791 byte *buf = (byte *)buffer;
00792 while (n > 0) {
00793 TileIndex ti = TileXY(MapMaxX(), y);
00794 for (uint x = MapMaxX(); true; x--) {
00795 *buf = 16 * TileHeight(ti);
00796 buf++;
00797 if (x == 0) break;
00798 ti = TILE_ADDXY(ti, -1, 0);
00799 }
00800 y++;
00801 n--;
00802 }
00803 }
00804
00809 bool MakeHeightmapScreenshot(const char *filename)
00810 {
00811 Colour palette[256];
00812 for (uint i = 0; i < lengthof(palette); i++) {
00813 palette[i].a = 0xff;
00814 palette[i].r = i;
00815 palette[i].g = i;
00816 palette[i].b = i;
00817 }
00818 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00819 return sf->proc(filename, HeightmapCallback, NULL, MapSizeX(), MapSizeY(), 8, palette);
00820 }
00821
00828 bool MakeScreenshot(ScreenshotType t, const char *name)
00829 {
00830 if (t == SC_VIEWPORT) {
00831
00832
00833
00834
00835 UndrawMouseCursor();
00836 DrawDirtyBlocks();
00837 }
00838
00839 _screenshot_name[0] = '\0';
00840 if (name != NULL) strecpy(_screenshot_name, name, lastof(_screenshot_name));
00841
00842 bool ret;
00843 switch (t) {
00844 case SC_VIEWPORT:
00845 case SC_RAW:
00846 ret = MakeSmallScreenshot();
00847 break;
00848
00849 case SC_ZOOMEDIN:
00850 ret = MakeZoomedInScreenshot();
00851 break;
00852
00853 case SC_WORLD:
00854 ret = MakeWorldScreenshot();
00855 break;
00856
00857 case SC_HEIGHTMAP: {
00858 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00859 ret = MakeHeightmapScreenshot(MakeScreenshotName(HEIGHTMAP_NAME, sf->extension));
00860 break;
00861 }
00862
00863 default:
00864 NOT_REACHED();
00865 }
00866
00867 if (ret) {
00868 SetDParamStr(0, _screenshot_name);
00869 ShowErrorMessage(STR_MESSAGE_SCREENSHOT_SUCCESSFULLY, INVALID_STRING_ID, WL_WARNING);
00870 } else {
00871 ShowErrorMessage(STR_ERROR_SCREENSHOT_FAILED, INVALID_STRING_ID, WL_ERROR);
00872 }
00873
00874 return ret;
00875 }