28 #include "table/strings.h" 70 #define MKCOLOUR(x) TO_LE32X(x) 77 PACK(
struct BitmapFileHeader {
83 assert_compile(
sizeof(BitmapFileHeader) == 14);
89 uint16 planes, bitcount;
90 uint32 compression, sizeimage, xpels, ypels, clrused, clrimp;
96 byte blue, green, red, reserved;
98 assert_compile(
sizeof(
RgbQuad) == 4);
115 switch (pixelformat) {
116 case 8: bpp = 1;
break;
118 case 32: bpp = 3;
break;
120 default:
return false;
123 FILE *f = fopen(name,
"wb");
124 if (f ==
nullptr)
return false;
127 uint bytewidth =
Align(w * bpp, 4);
130 uint pal_size = pixelformat == 8 ?
sizeof(
RgbQuad) * 256 : 0;
133 BitmapFileHeader bfh;
134 bfh.type = TO_LE16(
'MB');
135 bfh.size = TO_LE32(
sizeof(BitmapFileHeader) +
sizeof(
BitmapInfoHeader) + pal_size + bytewidth * h);
137 bfh.off_bits = TO_LE32(
sizeof(BitmapFileHeader) +
sizeof(
BitmapInfoHeader) + pal_size);
142 bih.width = TO_LE32(w);
143 bih.height = TO_LE32(h);
144 bih.planes = TO_LE16(1);
145 bih.bitcount = TO_LE16(bpp * 8);
154 if (fwrite(&bfh,
sizeof(bfh), 1, f) != 1 || fwrite(&bih,
sizeof(bih), 1, f) != 1) {
159 if (pixelformat == 8) {
162 for (uint i = 0; i < 256; i++) {
163 rq[i].red = palette[i].r;
164 rq[i].green = palette[i].g;
165 rq[i].blue = palette[i].b;
169 if (fwrite(rq,
sizeof(rq), 1, f) != 1) {
176 uint maxlines =
Clamp(65536 / (w * pixelformat / 8), 16, 128);
178 uint8 *buff = MallocT<uint8>(maxlines * w * pixelformat / 8);
179 uint8 *line =
AllocaM(uint8, bytewidth);
180 memset(line, 0, bytewidth);
184 uint n =
min(h, maxlines);
188 callb(userdata, buff, h, w, n);
192 if (pixelformat == 8) {
194 memcpy(line, buff + n * w, w);
200 for (uint i = 0; i < w; i++) {
201 dst[i * 3 ] = src[i].b;
202 dst[i * 3 + 1] = src[i].g;
203 dst[i * 3 + 2] = src[i].r;
207 if (fwrite(line, bytewidth, 1, f) != 1) {
224 #if defined(WITH_PNG) 227 #ifdef PNG_TEXT_SUPPORTED 235 static void PNGAPI
png_my_error(png_structp png_ptr, png_const_charp message)
237 DEBUG(misc, 0,
"[libpng] error: %s - %s", message, (
const char *)png_get_error_ptr(png_ptr));
238 longjmp(png_jmpbuf(png_ptr), 1);
241 static void PNGAPI
png_my_warning(png_structp png_ptr, png_const_charp message)
243 DEBUG(misc, 1,
"[libpng] warning: %s - %s", message, (
const char *)png_get_error_ptr(png_ptr));
264 uint bpp = pixelformat / 8;
269 if (pixelformat != 8 && pixelformat != 32)
return false;
271 f = fopen(name,
"wb");
272 if (f ==
nullptr)
return false;
276 if (png_ptr ==
nullptr) {
281 info_ptr = png_create_info_struct(png_ptr);
282 if (info_ptr ==
nullptr) {
283 png_destroy_write_struct(&png_ptr, (png_infopp)
nullptr);
288 if (setjmp(png_jmpbuf(png_ptr))) {
289 png_destroy_write_struct(&png_ptr, &info_ptr);
294 png_init_io(png_ptr, f);
296 png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
298 png_set_IHDR(png_ptr, info_ptr, w, h, 8, pixelformat == 8 ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_RGB,
299 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
301 #ifdef PNG_TEXT_SUPPORTED 304 png_text_struct text[2];
305 memset(text, 0,
sizeof(text));
306 text[0].key =
const_cast<char *
>(
"Software");
307 text[0].text =
const_cast<char *
>(_openttd_revision);
308 text[0].text_length = strlen(_openttd_revision);
309 text[0].compression = PNG_TEXT_COMPRESSION_NONE;
322 if (c->ai_info ==
nullptr) {
325 p +=
seprintf(p,
lastof(buf),
"%2i: %s (v%d)\n", (
int)c->index, c->ai_info->GetName(), c->ai_info->GetVersion());
328 text[1].key =
const_cast<char *
>(
"Description");
330 text[1].text_length = p - buf;
331 text[1].compression = PNG_TEXT_COMPRESSION_zTXt;
332 png_set_text(png_ptr, info_ptr, text, 2);
335 if (pixelformat == 8) {
337 for (i = 0; i != 256; i++) {
338 rq[i].red = palette[i].r;
339 rq[i].green = palette[i].g;
340 rq[i].blue = palette[i].b;
343 png_set_PLTE(png_ptr, info_ptr, rq, 256);
346 png_write_info(png_ptr, info_ptr);
347 png_set_flush(png_ptr, 512);
349 if (pixelformat == 32) {
358 png_set_sBIT(png_ptr, info_ptr, &sig_bit);
360 #if TTD_ENDIAN == TTD_LITTLE_ENDIAN 361 png_set_bgr(png_ptr);
362 png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
364 png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
369 maxlines =
Clamp(65536 / w, 16, 128);
372 void *buff = CallocT<uint8>(w * maxlines * bpp);
377 n =
min(h - y, maxlines);
380 callb(userdata, buff, y, w, n);
384 for (i = 0; i != n; i++) {
385 png_write_row(png_ptr, (png_bytep)buff + i * w * bpp);
389 png_write_end(png_ptr, info_ptr);
390 png_destroy_write_struct(&png_ptr, &info_ptr);
412 byte pal_small[16 * 3];
421 assert_compile(
sizeof(
PcxHeader) == 128);
443 if (pixelformat == 32) {
444 DEBUG(misc, 0,
"Can't convert a 32bpp screenshot to PCX format. Please pick another format.");
447 if (pixelformat != 8 || w == 0)
return false;
449 f = fopen(name,
"wb");
450 if (f ==
nullptr)
return false;
452 memset(&pcx, 0,
sizeof(pcx));
455 pcx.manufacturer = 10;
459 pcx.xmax = TO_LE16(w - 1);
460 pcx.ymax = TO_LE16(h - 1);
461 pcx.hdpi = TO_LE16(320);
462 pcx.vdpi = TO_LE16(320);
465 pcx.cpal = TO_LE16(1);
466 pcx.width = pcx.pitch = TO_LE16(w);
467 pcx.height = TO_LE16(h);
470 if (fwrite(&pcx,
sizeof(pcx), 1, f) != 1) {
476 maxlines =
Clamp(65536 / w, 16, 128);
479 uint8 *buff = CallocT<uint8>(w * maxlines);
484 uint n =
min(h - y, maxlines);
488 callb(userdata, buff, y, w, n);
492 for (i = 0; i != n; i++) {
493 const uint8 *bufp = buff + i * w;
494 byte runchar = bufp[0];
499 for (j = 1; j < w; j++) {
502 if (ch != runchar || runcount >= 0x3f) {
503 if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
504 if (fputc(0xC0 | runcount, f) == EOF) {
510 if (fputc(runchar, f) == EOF) {
522 if (runcount > 1 || (runchar & 0xC0) == 0xC0) {
523 if (fputc(0xC0 | runcount, f) == EOF) {
529 if (fputc(runchar, f) == EOF) {
540 if (fputc(12, f) == EOF) {
548 for (uint i = 0; i < 256; i++) {
549 tmp[i * 3 + 0] = palette[i].r;
550 tmp[i * 3 + 1] = palette[i].g;
551 tmp[i * 3 + 2] = palette[i].b;
553 success = fwrite(tmp,
sizeof(tmp), 1, f) == 1;
566 #if defined(WITH_PNG) 583 for (uint i = 0; i <
lengthof(_screenshot_formats); i++) {
600 void *src = blitter->
MoveTo(_screen.dst_ptr, 0, y);
622 _screen.dst_ptr = buf;
623 _screen.width = pitch;
625 _screen.pitch = pitch;
633 dpi.width = vp->
width;
641 while (vp->
width - left != 0) {
656 _screen = old_screen;
667 static const char *
MakeScreenshotName(
const char *default_fn,
const char *ext,
bool crashlog =
false)
685 for (uint serial = 1;; serial++) {
691 if (!generate)
break;
727 vp->
width = _screen.width;
728 vp->
height = _screen.height;
754 vp->overlay =
nullptr;
771 vp->overlay =
nullptr;
803 byte *buf = (byte *)buffer;
806 for (uint x =
MapMaxX();
true; x--) {
824 for (uint i = 0; i <
lengthof(palette); i++) {
922 static void MinimapScreenCallback(
void *userdata,
void *buf, uint y, uint pitch, uint n)
937 uint32 *ubuf = (uint32 *)buf;
938 uint num = (pitch * n);
939 for (uint i = 0; i < num; i++) {
940 uint row = y + (int)(i / pitch);
941 uint col = (
MapSizeX() - 1) - (i % pitch);
945 byte val = owner_colours[o];
947 uint32 colour_buf = 0;
Functions related to OTTD's strings.
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
Owner
Enum for all companies/owners.
char _screenshot_format_name[8]
Extension of the current screenshot format (corresponds with _cur_screenshot_format).
uint8 max_heightlevel
maximum allowed heightlevel
static uint MapSizeX()
Get the size of the map along the X.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
static bool MakeSmallScreenshot(bool crashlog)
Make a screenshot of the current screen.
Definition of stuff that is very close to a company, like the company struct itself.
char _full_screenshot_name[MAX_PATH]
Pathname of the screenshot file.
void InitializeScreenshotFormats()
Initialize screenshot format information on startup, with _screenshot_format_name filled from the loa...
int virtual_left
Virtual left coordinate.
Data about how and where to blit pixels.
static uint MapSizeY()
Get the size of the map along the Y.
GRFConfig * _grfconfig
First item in list of current GRF set up.
void GenerateDefaultSaveName(char *buf, const char *last)
Fill the buffer with the default name for a savegame or screenshot.
int height
Screen height of the viewport.
static Point RemapCoords(int x, int y, int z)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap...
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
static void PNGAPI png_my_warning(png_structp png_ptr, png_const_charp message)
Handle warning in pnglib.
Colour palette[256]
Current palette. Entry 0 has to be always fully transparent!
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
static int UnScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZOOM_LVL_NORMAL) When shifting right...
A town owns the tile, or a town is expanding.
uint8 a
colour channels in LE order
char * md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
Convert the md5sum to a hexadecimal string representation.
int virtual_height
height << zoom
static uint TileX(TileIndex tile)
Get the X component of a tile.
static int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZOOM_LVL_NORMAL) When shifting right...
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=nullptr, uint textref_stack_size=0, const uint32 *textref_stack=nullptr)
Display an error message in a window.
Functions for Standard In/Out file operations.
PACK(struct BitmapFileHeader { uint16 type;uint32 size;uint32 reserved;uint32 off_bits;})
BMP File Header (stored in little endian)
static void PNGAPI png_my_error(png_structp png_ptr, png_const_charp message)
Handle pnglib error.
bool ScreenshotHandlerProc(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
Function signature for a screenshot generation routine for one of the available formats.
#define lastof(x)
Get the last element of an fixed size array.
Function to handling different endian machines.
Functions to make screenshots.
#define AllocaM(T, num_elements)
alloca() has to be called in the parent function, so define AllocaM() as a macro
uint _num_screenshot_formats
Number of available screenshot formats.
How all blitters should look like.
virtual void CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch)=0
Copy from the screen to a buffer in a palette format for 8bpp and RGBA format for 32bpp...
Fully zoomed in screenshot of the visible area.
static const uint TILE_SIZE
Tile size in world coordinates.
struct GRFConfig * next
NOSAVE: Next item in the linked list.
static const uint8 PC_GRASS_LAND
Dark green palette colour for grass land.
Functions, definitions and such used only by the GUI.
Functions related to (drawing on) viewports.
void SetupScreenshotViewport(ScreenshotType t, ViewPort *vp)
Configure a ViewPort for rendering (a part of) the map into a screenshot.
bool freeform_edges
allow terraforming the tiles at the map edges
Data structure for an opened window.
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Main window; Window numbers:
The tile has no ownership.
Functions/types related to saving and loading games.
static const uint8 PC_DARK_GREY
Dark grey palette colour.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Functions related to errors.
static const char *const HEIGHTMAP_NAME
Default filename of a saved heightmap.
static T Align(const T x, uint n)
Return the smallest multiple of n equal or greater than x.
The client is spectating.
void ScreenshotCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
Callback function signature for generating lines of pixel data to be written to the screenshot file...
Information about GRF, used in the game and (part of it) in savegames.
static Owner GetMinimapOwner(TileIndex tile)
Return the owner of a tile to display it with in the small map in mode "Owner".
bool MakeMinimapWorldScreenshot()
Make a minimap screenshot.
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Functions related to the gfx engine.
ClientSettings _settings_client
The current settings for this game.
bool FileExists(const char *filename)
Test whether the given filename exists.
Definition of base types and functions in a cross-platform compatible way.
static void HeightmapCallback(void *userdata, void *buffer, uint y, uint pitch, uint n)
Callback for generating a heightmap.
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
A number of safeguards to prevent using unsafe methods.
Default zoom level for the world screen shot.
static const ScreenshotFormat _screenshot_formats[]
Available screenshot formats.
static void CurrentScreenCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
Callback of the screenshot generator that dumps the current video buffer.
static const char * MakeScreenshotName(const char *default_fn, const char *ext, bool crashlog=false)
Construct a pathname for a screenshot file.
const char * _personal_dir
custom directory for personal settings, saves, newgrf, etc.
bool _screen_disable_anim
Disable palette animation (important for 32bpp-anim blitter during giant screenshot) ...
static bool MakePCXImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
Generic .PCX file image writer.
int virtual_width
width << zoom
#define lengthof(x)
Return the length of an fixed size array.
void DrawDirtyBlocks()
Repaints the rectangle blocks which are marked as 'dirty'.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
static T min(const T a, const T b)
Returns the minimum of two values.
static const uint8 PC_BLACK
Black palette colour.
Functions to find and configure NewGRFs.
static bool MakePNGImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
Generic .PNG file image writer.
Palette _cur_palette
Current palette.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
bool MakeScreenshot(ScreenshotType t, const char *name)
Make an actual screenshot.
#define DEBUG(name, level,...)
Output a line of debugging information.
static const char *const SCREENSHOT_NAME
Default filename of a saved screenshot.
int left
Screen coordinate left edge of the viewport.
Format of palette data in BMP header.
static const uint8 PC_DARK_RED
Dark red palette colour.
The tile/execution is done by "water".
uint _cur_screenshot_format
Index of the currently selected screenshot format in _screenshot_formats.
Functions related to companies.
static uint MapSize()
Get the size of the map.
GUISettings gui
settings related to the GUI
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Invisible tiles at the SW and SE border.
static bool MakeLargeWorldScreenshot(ScreenshotType t)
Make a screenshot of the map.
Data structure for viewport, display of a part of the world.
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Default zoom level for viewports.
Zoomed to default zoom level screenshot of the visible area.
uint32 TileIndex
The index/ID of a Tile.
static char _screenshot_name[128]
Filename of the screenshot file.
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Functions related to zooming.
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
const char * GetCurrentScreenshotExtension()
Get filename extension of current screenshot file format.
virtual void * MoveTo(void *video, int x, int y)=0
Move the destination pointer the requested amount x and y, keeping in mind any pitch and bpp of the r...
Functions related to OTTD's landscape.
static const uint8 PC_WATER
Dark blue palette colour for water.
Structure to access the alpha, red, green, and blue channels from a 32 bit number.
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
virtual uint8 GetScreenDepth()=0
Get the screen depth this blitter works for.
ConstructionSettings construction
construction of things in-game
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
declaration of OTTD revision dependent variables
ZoomLevel zoom
The zoom level of the viewport.
int virtual_top
Virtual top coordinate.
const char * FiosGetScreenshotDir()
Get the directory for screenshots.
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Map writing/reading functions for tiles.
static uint32 BSWAP32(uint32 x)
Perform a 32 bits endianness bitswap on x.
Window functions not directly related to making/drawing windows.
int top
Screen coordinate top edge of the viewport.
AIInfo keeps track of all information of an AI, like Author, Description, ...
static bool MakeBMPImage(const char *name, ScreenshotCallback *callb, void *userdata, uint w, uint h, int pixelformat, const Colour *palette)
Generic .BMP writer.
ZoomLevel zoom_min
minimum zoom out level
ViewportData * viewport
Pointer to viewport data, if present.
bool MakeHeightmapScreenshot(const char *filename)
Make a heightmap of the current map.
Errors (eg. saving/loading failed)
Raw screenshot from blitter buffer.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
The object is owned by a superuser / goal script.
Factory to 'query' all available blitters.
static void LargeWorldCallback(void *userdata, void *buf, uint y, uint pitch, uint n)
generate a large piece of the world
static uint TilePixelHeight(TileIndex tile)
Returns the height of a tile in pixels.
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
ScreenshotType
Type of requested screenshot.
int width
Screen width of the viewport.