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 "error.h"
00024 #include "window_gui.h"
00025 #include "window_func.h"
00026 #include "tile_map.h"
00027 #include "landscape.h"
00028
00029 #include "table/strings.h"
00030
00031 static const char * const SCREENSHOT_NAME = "screenshot";
00032 static const char * const HEIGHTMAP_NAME = "heightmap";
00033
00034 char _screenshot_format_name[8];
00035 uint _num_screenshot_formats;
00036 uint _cur_screenshot_format;
00037 static char _screenshot_name[128];
00038 char _full_screenshot_name[MAX_PATH];
00039
00048 typedef void ScreenshotCallback(void *userdata, void *buf, uint y, uint pitch, uint n);
00049
00061 typedef bool ScreenshotHandlerProc(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette);
00062
00064 struct ScreenshotFormat {
00065 const char *name;
00066 const char *extension;
00067 ScreenshotHandlerProc *proc;
00068 bool supports_32bpp;
00069 };
00070
00071
00072
00073
00074 #if defined(_MSC_VER) || defined(__WATCOMC__)
00075 #pragma pack(push, 1)
00076 #endif
00077
00079 struct BitmapFileHeader {
00080 uint16 type;
00081 uint32 size;
00082 uint32 reserved;
00083 uint32 off_bits;
00084 } GCC_PACK;
00085 assert_compile(sizeof(BitmapFileHeader) == 14);
00086
00087 #if defined(_MSC_VER) || defined(__WATCOMC__)
00088 #pragma pack(pop)
00089 #endif
00090
00092 struct BitmapInfoHeader {
00093 uint32 size;
00094 int32 width, height;
00095 uint16 planes, bitcount;
00096 uint32 compression, sizeimage, xpels, ypels, clrused, clrimp;
00097 };
00098 assert_compile(sizeof(BitmapInfoHeader) == 40);
00099
00101 struct RgbQuad {
00102 byte blue, green, red, reserved;
00103 };
00104 assert_compile(sizeof(RgbQuad) == 4);
00105
00118 static bool MakeBMPImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
00119 {
00120 uint bpp;
00121 switch (pixelformat) {
00122 case 8: bpp = 1; break;
00123
00124 case 32: bpp = 3; break;
00125
00126 default: return false;
00127 }
00128
00129 FILE *f = fopen(name, "wb");
00130 if (f == NULL) return false;
00131
00132
00133 uint bytewidth = Align(w * bpp, 4);
00134
00135
00136 uint pal_size = pixelformat == 8 ? sizeof(RgbQuad) * 256 : 0;
00137
00138
00139 BitmapFileHeader bfh;
00140 bfh.type = TO_LE16('MB');
00141 bfh.size = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size + bytewidth * h);
00142 bfh.reserved = 0;
00143 bfh.off_bits = TO_LE32(sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader) + pal_size);
00144
00145
00146 BitmapInfoHeader bih;
00147 bih.size = TO_LE32(sizeof(BitmapInfoHeader));
00148 bih.width = TO_LE32(w);
00149 bih.height = TO_LE32(h);
00150 bih.planes = TO_LE16(1);
00151 bih.bitcount = TO_LE16(bpp * 8);
00152 bih.compression = 0;
00153 bih.sizeimage = 0;
00154 bih.xpels = 0;
00155 bih.ypels = 0;
00156 bih.clrused = 0;
00157 bih.clrimp = 0;
00158
00159
00160 if (fwrite(&bfh, sizeof(bfh), 1, f) != 1 || fwrite(&bih, sizeof(bih), 1, f) != 1) {
00161 fclose(f);
00162 return false;
00163 }
00164
00165 if (pixelformat == 8) {
00166
00167 RgbQuad rq[256];
00168 for (uint i = 0; i < 256; i++) {
00169 rq[i].red = palette[i].r;
00170 rq[i].green = palette[i].g;
00171 rq[i].blue = palette[i].b;
00172 rq[i].reserved = 0;
00173 }
00174
00175 if (fwrite(rq, sizeof(rq), 1, f) != 1) {
00176 fclose(f);
00177 return false;
00178 }
00179 }
00180
00181
00182 uint maxlines = Clamp(65536 / (w * pixelformat / 8), 16, 128);
00183
00184 uint8 *buff = MallocT<uint8>(maxlines * w * pixelformat / 8);
00185 uint8 *line = AllocaM(uint8, bytewidth);
00186 memset(line, 0, bytewidth);
00187
00188
00189 do {
00190 uint n = min(h, maxlines);
00191 h -= n;
00192
00193
00194 callb(userdata, buff, h, w, n);
00195
00196
00197 while (n-- != 0) {
00198 if (pixelformat == 8) {
00199
00200 memcpy(line, buff + n * w, w);
00201 } else {
00202
00203
00204 Colour *src = ((Colour *)buff) + n * w;
00205 byte *dst = line;
00206 for (uint i = 0; i < w; i++) {
00207 dst[i * 3 ] = src[i].b;
00208 dst[i * 3 + 1] = src[i].g;
00209 dst[i * 3 + 2] = src[i].r;
00210 }
00211 }
00212
00213 if (fwrite(line, bytewidth, 1, f) != 1) {
00214 free(buff);
00215 fclose(f);
00216 return false;
00217 }
00218 }
00219 } while (h != 0);
00220
00221 free(buff);
00222 fclose(f);
00223
00224 return true;
00225 }
00226
00227
00228
00229
00230 #if defined(WITH_PNG)
00231 #include <png.h>
00232
00233 #ifdef PNG_TEXT_SUPPORTED
00234 #include "rev.h"
00235 #include "newgrf_config.h"
00236 #include "ai/ai_info.hpp"
00237 #include "company_base.h"
00238 #include "base_media_base.h"
00239 #endif
00240
00241 static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)
00242 {
00243 DEBUG(misc, 0, "[libpng] error: %s - %s", message, (const char *)png_get_error_ptr(png_ptr));
00244 longjmp(png_jmpbuf(png_ptr), 1);
00245 }
00246
00247 static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)
00248 {
00249 DEBUG(misc, 1, "[libpng] warning: %s - %s", message, (const char *)png_get_error_ptr(png_ptr));
00250 }
00251
00264 static bool MakePNGImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
00265 {
00266 png_color rq[256];
00267 FILE *f;
00268 uint i, y, n;
00269 uint maxlines;
00270 uint bpp = pixelformat / 8;
00271 png_structp png_ptr;
00272 png_infop info_ptr;
00273
00274
00275 if (pixelformat != 8 && pixelformat != 32) return false;
00276
00277 f = fopen(name, "wb");
00278 if (f == NULL) return false;
00279
00280 png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, const_cast<char *>(name), png_my_error, png_my_warning);
00281
00282 if (png_ptr == NULL) {
00283 fclose(f);
00284 return false;
00285 }
00286
00287 info_ptr = png_create_info_struct(png_ptr);
00288 if (info_ptr == NULL) {
00289 png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
00290 fclose(f);
00291 return false;
00292 }
00293
00294 if (setjmp(png_jmpbuf(png_ptr))) {
00295 png_destroy_write_struct(&png_ptr, &info_ptr);
00296 fclose(f);
00297 return false;
00298 }
00299
00300 png_init_io(png_ptr, f);
00301
00302 png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
00303
00304 png_set_IHDR(png_ptr, info_ptr, w, h, 8, pixelformat == 8 ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_RGB,
00305 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
00306
00307 #ifdef PNG_TEXT_SUPPORTED
00308
00309
00310 png_text_struct text[2];
00311 memset(text, 0, sizeof(text));
00312 text[0].key = const_cast<char *>("Software");
00313 text[0].text = const_cast<char *>(_openttd_revision);
00314 text[0].text_length = strlen(_openttd_revision);
00315 text[0].compression = PNG_TEXT_COMPRESSION_NONE;
00316
00317 char buf[8192];
00318 char *p = buf;
00319 p += seprintf(p, lastof(buf), "Graphics set: %s (%u)\n", BaseGraphics::GetUsedSet()->name, BaseGraphics::GetUsedSet()->version);
00320 p = strecpy(p, "NewGRFs:\n", lastof(buf));
00321 for (const GRFConfig *c = _game_mode == GM_MENU ? NULL : _grfconfig; c != NULL; c = c->next) {
00322 p += seprintf(p, lastof(buf), "%08X ", BSWAP32(c->ident.grfid));
00323 p = md5sumToString(p, lastof(buf), c->ident.md5sum);
00324 p += seprintf(p, lastof(buf), " %s\n", c->filename);
00325 }
00326 p = strecpy(p, "\nCompanies:\n", lastof(buf));
00327 const Company *c;
00328 FOR_ALL_COMPANIES(c) {
00329 if (c->ai_info == NULL) {
00330 p += seprintf(p, lastof(buf), "%2i: Human\n", (int)c->index);
00331 } else {
00332 p += seprintf(p, lastof(buf), "%2i: %s (v%d)\n", (int)c->index, c->ai_info->GetName(), c->ai_info->GetVersion());
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, true},
00575 #endif
00576 {"BMP", "bmp", &MakeBMPImage, true},
00577 {"PCX", "pcx", &MakePCXImage, false},
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
00615 bool GetScreenshotFormatSupports_32bpp(int i)
00616 {
00617 return _screenshot_formats[i].supports_32bpp;
00618 }
00619
00624 void SetScreenshotFormat(uint i)
00625 {
00626 assert(i < _num_screenshot_formats);
00627 _cur_screenshot_format = i;
00628 strecpy(_screenshot_format_name, _screenshot_formats[i].extension, lastof(_screenshot_format_name));
00629 }
00630
00635 static void CurrentScreenCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
00636 {
00637 Blitter *blitter = BlitterFactory::GetCurrentBlitter();
00638 void *src = blitter->MoveTo(_screen.dst_ptr, 0, y);
00639 blitter->CopyImageToBuffer(src, buf, _screen.width, n, pitch);
00640 }
00641
00650 static void LargeWorldCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
00651 {
00652 ViewPort *vp = (ViewPort *)userdata;
00653 DrawPixelInfo dpi, *old_dpi;
00654 int wx, left;
00655
00656
00657 DrawPixelInfo old_screen = _screen;
00658 bool old_disable_anim = _screen_disable_anim;
00659
00660 _screen.dst_ptr = buf;
00661 _screen.width = pitch;
00662 _screen.height = n;
00663 _screen.pitch = pitch;
00664 _screen_disable_anim = true;
00665
00666 old_dpi = _cur_dpi;
00667 _cur_dpi = &dpi;
00668
00669 dpi.dst_ptr = buf;
00670 dpi.height = n;
00671 dpi.width = vp->width;
00672 dpi.pitch = pitch;
00673 dpi.zoom = ZOOM_LVL_WORLD_SCREENSHOT;
00674 dpi.left = 0;
00675 dpi.top = y;
00676
00677
00678 left = 0;
00679 while (vp->width - left != 0) {
00680 wx = min(vp->width - left, 1600);
00681 left += wx;
00682
00683 ViewportDoDraw(vp,
00684 ScaleByZoom(left - wx - vp->left, vp->zoom) + vp->virtual_left,
00685 ScaleByZoom(y - vp->top, vp->zoom) + vp->virtual_top,
00686 ScaleByZoom(left - vp->left, vp->zoom) + vp->virtual_left,
00687 ScaleByZoom((y + n) - vp->top, vp->zoom) + vp->virtual_top
00688 );
00689 }
00690
00691 _cur_dpi = old_dpi;
00692
00693
00694 _screen = old_screen;
00695 _screen_disable_anim = old_disable_anim;
00696 }
00697
00705 static const char *MakeScreenshotName(const char *default_fn, const char *ext, bool crashlog = false)
00706 {
00707 bool generate = StrEmpty(_screenshot_name);
00708
00709 if (generate) {
00710 if (_game_mode == GM_EDITOR || _game_mode == GM_MENU || _local_company == COMPANY_SPECTATOR) {
00711 strecpy(_screenshot_name, default_fn, lastof(_screenshot_name));
00712 } else {
00713 GenerateDefaultSaveName(_screenshot_name, lastof(_screenshot_name));
00714 }
00715 }
00716
00717
00718 size_t len = strlen(_screenshot_name);
00719 snprintf(&_screenshot_name[len], lengthof(_screenshot_name) - len, ".%s", ext);
00720
00721 const char *screenshot_dir = crashlog ? _personal_dir : FiosGetScreenshotDir();
00722
00723 for (uint serial = 1;; serial++) {
00724 if (snprintf(_full_screenshot_name, lengthof(_full_screenshot_name), "%s%s", screenshot_dir, _screenshot_name) >= (int)lengthof(_full_screenshot_name)) {
00725
00726 _full_screenshot_name[0] = '\0';
00727 break;
00728 }
00729 if (!generate) break;
00730 if (!FileExists(_full_screenshot_name)) break;
00731
00732 snprintf(&_screenshot_name[len], lengthof(_screenshot_name) - len, "#%u.%s", serial, ext);
00733 }
00734
00735 return _full_screenshot_name;
00736 }
00737
00739 static bool MakeSmallScreenshot(bool crashlog)
00740 {
00741 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00742 return sf->proc(MakeScreenshotName(SCREENSHOT_NAME, sf->extension, crashlog), CurrentScreenCallback, NULL, _screen.width, _screen.height,
00743 BlitterFactory::GetCurrentBlitter()->GetScreenDepth(), _cur_palette.palette);
00744 }
00745
00751 void SetupScreenshotViewport(ScreenshotType t, ViewPort *vp)
00752 {
00753
00754 if (t == SC_WORLD) {
00755 vp->zoom = ZOOM_LVL_WORLD_SCREENSHOT;
00756
00757 TileIndex north_tile = _settings_game.construction.freeform_edges ? TileXY(1, 1) : TileXY(0, 0);
00758 TileIndex south_tile = MapSize() - 1;
00759
00760
00761 int extra_height_top = TilePixelHeight(north_tile) + 150;
00762
00763 int reclaim_height_bottom = TilePixelHeight(south_tile);
00764
00765 vp->virtual_left = RemapCoords(TileX(south_tile) * TILE_SIZE, TileY(north_tile) * TILE_SIZE, 0).x;
00766 vp->virtual_top = RemapCoords(TileX(north_tile) * TILE_SIZE, TileY(north_tile) * TILE_SIZE, extra_height_top).y;
00767 vp->virtual_width = RemapCoords(TileX(north_tile) * TILE_SIZE, TileY(south_tile) * TILE_SIZE, 0).x - vp->virtual_left + 1;
00768 vp->virtual_height = RemapCoords(TileX(south_tile) * TILE_SIZE, TileY(south_tile) * TILE_SIZE, reclaim_height_bottom).y - vp->virtual_top + 1;
00769 } else {
00770 vp->zoom = (t == SC_ZOOMEDIN) ? _settings_client.gui.zoom_min : ZOOM_LVL_VIEWPORT;
00771
00772 Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
00773 vp->virtual_left = w->viewport->virtual_left;
00774 vp->virtual_top = w->viewport->virtual_top;
00775 vp->virtual_width = w->viewport->virtual_width;
00776 vp->virtual_height = w->viewport->virtual_height;
00777 }
00778
00779
00780 vp->left = 0;
00781 vp->top = 0;
00782 vp->width = UnScaleByZoom(vp->virtual_width, vp->zoom);
00783 vp->height = UnScaleByZoom(vp->virtual_height, vp->zoom);
00784 vp->overlay = NULL;
00785 }
00786
00792 static bool MakeLargeWorldScreenshot(ScreenshotType t)
00793 {
00794 ViewPort vp;
00795 SetupScreenshotViewport(t, &vp);
00796
00797 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00798 return sf->proc(MakeScreenshotName(SCREENSHOT_NAME, sf->extension), LargeWorldCallback, &vp, vp.width, vp.height,
00799 BlitterFactory::GetCurrentBlitter()->GetScreenDepth(), _cur_palette.palette);
00800 }
00801
00811 static void HeightmapCallback(void *userdata, void *buffer, uint y, uint pitch, uint n)
00812 {
00813 byte *buf = (byte *)buffer;
00814 while (n > 0) {
00815 TileIndex ti = TileXY(MapMaxX(), y);
00816 for (uint x = MapMaxX(); true; x--) {
00817 *buf = 16 * TileHeight(ti);
00818 buf++;
00819 if (x == 0) break;
00820 ti = TILE_ADDXY(ti, -1, 0);
00821 }
00822 y++;
00823 n--;
00824 }
00825 }
00826
00831 bool MakeHeightmapScreenshot(const char *filename)
00832 {
00833 Colour palette[256];
00834 for (uint i = 0; i < lengthof(palette); i++) {
00835 palette[i].a = 0xff;
00836 palette[i].r = i;
00837 palette[i].g = i;
00838 palette[i].b = i;
00839 }
00840 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00841 return sf->proc(filename, HeightmapCallback, NULL, MapSizeX(), MapSizeY(), 8, palette);
00842 }
00843
00850 bool MakeScreenshot(ScreenshotType t, const char *name)
00851 {
00852 if (t == SC_VIEWPORT) {
00853
00854
00855
00856
00857 UndrawMouseCursor();
00858 DrawDirtyBlocks();
00859 }
00860
00861 _screenshot_name[0] = '\0';
00862 if (name != NULL) strecpy(_screenshot_name, name, lastof(_screenshot_name));
00863
00864 bool ret;
00865 switch (t) {
00866 case SC_VIEWPORT:
00867 ret = MakeSmallScreenshot(false);
00868 break;
00869
00870 case SC_CRASHLOG:
00871 ret = MakeSmallScreenshot(true);
00872 break;
00873
00874 case SC_ZOOMEDIN:
00875 case SC_DEFAULTZOOM:
00876 case SC_WORLD:
00877 ret = MakeLargeWorldScreenshot(t);
00878 break;
00879
00880 case SC_HEIGHTMAP: {
00881 const ScreenshotFormat *sf = _screenshot_formats + _cur_screenshot_format;
00882 ret = MakeHeightmapScreenshot(MakeScreenshotName(HEIGHTMAP_NAME, sf->extension));
00883 break;
00884 }
00885
00886 default:
00887 NOT_REACHED();
00888 }
00889
00890 if (ret) {
00891 SetDParamStr(0, _screenshot_name);
00892 ShowErrorMessage(STR_MESSAGE_SCREENSHOT_SUCCESSFULLY, INVALID_STRING_ID, WL_WARNING);
00893 } else {
00894 ShowErrorMessage(STR_ERROR_SCREENSHOT_FAILED, INVALID_STRING_ID, WL_ERROR);
00895 }
00896
00897 return ret;
00898 }