1

/* $Id$ */

     2

     3

/** @file heightmap.cpp Creating of maps from heightmaps. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "heightmap.h"

     9

#include "clear_map.h"

    10

#include "void_map.h"

    11

#include "debug.h"

    12

#include "gui.h"

    13

#include "saveload.h"

    14

#include "bmp.h"

    15

#include "gfx_func.h"

    16

#include "core/alloc_func.hpp"

    17

#include "fios.h"

    18

#include "settings_type.h"

    19

    20

#include "table/strings.h"

    21

    22

/**

    23

 * Convert RGB colors to Grayscale using 29.9% Red, 58.7% Green, 11.4% Blue

    24

 *  (average luminosity formula) -- Dalestan

    25

 * This in fact is the NTSC Color Space -- TrueLight

    26

 */

    27

static inline byte RGBToGrayscale(byte red, byte green, byte blue)

    28

{

    29

	/* To avoid doubles and stuff, multiple it with a total of 65536 (16bits), then

    30

	 *  divide by it to normalize the value to a byte again. */

    31

	return ((red * 19595) + (green * 38470) + (blue * 7471)) / 65536;

    32

}

    33

    34

    35

#ifdef WITH_PNG

    36

    37

#include <png.h>

    38

    39

/**

    40

 * The PNG Heightmap loader.

    41

 */

    42

static void ReadHeightmapPNGImageData(byte *map, png_structp png_ptr, png_infop info_ptr)

    43

{

    44

	uint x, y;

    45

	byte gray_palette[256];

    46

	png_bytep *row_pointers = NULL;

    47

    48

	/* Get palette and convert it to grayscale */

    49

	if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {

    50

		int i;

    51

		int palette_size;

    52

		png_color *palette;

    53

		bool all_gray = true;

    54

    55

		png_get_PLTE(png_ptr, info_ptr, &palette, &palette_size);

    56

		for (i = 0; i < palette_size && (palette_size != 16 || all_gray); i++) {

    57

			all_gray &= palette[i].red == palette[i].green && palette[i].red == palette[i].blue;

    58

			gray_palette[i] = RGBToGrayscale(palette[i].red, palette[i].green, palette[i].blue);

    59

		}

    60

    61

		/**

    62

		 * For a non-gray palette of size 16 we assume that

    63

		 * the order of the palette determines the height;

    64

		 * the first entry is the sea (level 0), the second one

    65

		 * level 1, etc.

    66

		 */

    67

		if (palette_size == 16 && !all_gray) {

    68

			for (i = 0; i < palette_size; i++) {

    69

				gray_palette[i] = 256 * i / palette_size;

    70

			}

    71

		}

    72

	}

    73

    74

	row_pointers = png_get_rows(png_ptr, info_ptr);

    75

    76

	/* Read the raw image data and convert in 8-bit grayscale */

    77

	for (x = 0; x < info_ptr->width; x++) {

    78

		for (y = 0; y < info_ptr->height; y++) {

    79

			byte *pixel = &map[y * info_ptr->width + x];

    80

			uint x_offset = x * info_ptr->channels;

    81

    82

			if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {

    83

				*pixel = gray_palette[row_pointers[y][x_offset]];

    84

			} else if (info_ptr->channels == 3) {

    85

				*pixel = RGBToGrayscale(row_pointers[y][x_offset + 0],

    86

						row_pointers[y][x_offset + 1], row_pointers[y][x_offset + 2]);

    87

			} else {

    88

				*pixel = row_pointers[y][x_offset];

    89

			}

    90

		}

    91

	}

    92

}

    93

    94

/**

    95

 * Reads the heightmap and/or size of the heightmap from a PNG file.

    96

 * If map == NULL only the size of the PNG is read, otherwise a map

    97

 * with grayscale pixels is allocated and assigned to *map.

    98

 */

    99

static bool ReadHeightmapPNG(char *filename, uint *x, uint *y, byte **map)

   100

{

   101

	FILE *fp;

   102

	png_structp png_ptr = NULL;

   103

	png_infop info_ptr  = NULL;

   104

   105

	fp = fopen(filename, "rb");

   106

	if (fp == NULL) {

   107

		ShowErrorMessage(STR_PNGMAP_ERR_FILE_NOT_FOUND, STR_PNGMAP_ERROR, 0, 0);

   108

		return false;

   109

	}

   110

   111

	png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

   112

	if (png_ptr == NULL) {

   113

		ShowErrorMessage(STR_PNGMAP_ERR_MISC, STR_PNGMAP_ERROR, 0, 0);

   114

		fclose(fp);

   115

		return false;

   116

	}

   117

   118

	info_ptr = png_create_info_struct(png_ptr);

   119

	if (info_ptr == NULL || setjmp(png_jmpbuf(png_ptr))) {

   120

		ShowErrorMessage(STR_PNGMAP_ERR_MISC, STR_PNGMAP_ERROR, 0, 0);

   121

		fclose(fp);

   122

		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

   123

		return false;

   124

	}

   125

   126

	png_init_io(png_ptr, fp);

   127

   128

	/* Allocate memory and read image, without alpha or 16-bit samples

   129

	 * (result is either 8-bit indexed/grayscale or 24-bit RGB) */

   130

	png_set_packing(png_ptr);

   131

	png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_STRIP_16, NULL);

   132

   133

	/* Maps of wrong color-depth are not used.

   134

	 * (this should have been taken care of by stripping alpha and 16-bit samples on load) */

   135

	if ((info_ptr->channels != 1) && (info_ptr->channels != 3) && (info_ptr->bit_depth != 8)) {

   136

		ShowErrorMessage(STR_PNGMAP_ERR_IMAGE_TYPE, STR_PNGMAP_ERROR, 0, 0);

   137

		fclose(fp);

   138

		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

   139

		return false;

   140

	}

   141

   142

	if (map != NULL) {

   143

		*map = MallocT<byte>(info_ptr->width * info_ptr->height);

   144

   145

		if (*map == NULL) {

   146

			ShowErrorMessage(STR_PNGMAP_ERR_MISC, STR_PNGMAP_ERROR, 0, 0);

   147

			fclose(fp);

   148

			png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

   149

			return false;

   150

		}

   151

   152

		ReadHeightmapPNGImageData(*map, png_ptr, info_ptr);

   153

	}

   154

   155

	*x = info_ptr->width;

   156

	*y = info_ptr->height;

   157

   158

	fclose(fp);

   159

	png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

   160

	return true;

   161

}

   162

   163

#endif /* WITH_PNG */

   164

   165

   166

/**

   167

 * The BMP Heightmap loader.

   168

 */

   169

static void ReadHeightmapBMPImageData(byte *map, BmpInfo *info, BmpData *data)

   170

{

   171

	uint x, y;

   172

	byte gray_palette[256];

   173

   174

	if (data->palette != NULL) {

   175

		uint i;

   176

		bool all_gray = true;

   177

   178

		if (info->palette_size != 2) {

   179

			for (i = 0; i < info->palette_size && (info->palette_size != 16 || all_gray); i++) {

   180

				all_gray &= data->palette[i].r == data->palette[i].g && data->palette[i].r == data->palette[i].b;

   181

				gray_palette[i] = RGBToGrayscale(data->palette[i].r, data->palette[i].g, data->palette[i].b);

   182

			}

   183

   184

			/**

   185

			 * For a non-gray palette of size 16 we assume that

   186

			 * the order of the palette determines the height;

   187

			 * the first entry is the sea (level 0), the second one

   188

			 * level 1, etc.

   189

			 */

   190

			if (info->palette_size == 16 && !all_gray) {

   191

				for (i = 0; i < info->palette_size; i++) {

   192

					gray_palette[i] = 256 * i / info->palette_size;

   193

				}

   194

			}

   195

		} else {

   196

			/**

   197

			 * For a palette of size 2 we assume that the order of the palette determines the height;

   198

			 * the first entry is the sea (level 0), the second one is the land (level 1)

   199

			 */

   200

			gray_palette[0] = 0;

   201

			gray_palette[1] = 16;

   202

		}

   203

	}

   204

   205

	/* Read the raw image data and convert in 8-bit grayscale */

   206

	for (y = 0; y < info->height; y++) {

   207

		byte *pixel = &map[y * info->width];

   208

		byte *bitmap = &data->bitmap[y * info->width * (info->bpp == 24 ? 3 : 1)];

   209

   210

		for (x = 0; x < info->width; x++) {

   211

			if (info->bpp != 24) {

   212

				*pixel++ = gray_palette[*bitmap++];

   213

			} else {

   214

				*pixel++ = RGBToGrayscale(*bitmap, *(bitmap + 1), *(bitmap + 2));

   215

				bitmap += 3;

   216

			}

   217

		}

   218

	}

   219

}

   220

   221

/**

   222

 * Reads the heightmap and/or size of the heightmap from a BMP file.

   223

 * If map == NULL only the size of the BMP is read, otherwise a map

   224

 * with grayscale pixels is allocated and assigned to *map.

   225

 */

   226

static bool ReadHeightmapBMP(char *filename, uint *x, uint *y, byte **map)

   227

{

   228

	FILE *f;

   229

	BmpInfo info;

   230

	BmpData data;

   231

	BmpBuffer buffer;

   232

   233

	/* Init BmpData */

   234

	memset(&data, 0, sizeof(data));

   235

   236

	f = fopen(filename, "rb");

   237

	if (f == NULL) {

   238

		ShowErrorMessage(STR_PNGMAP_ERR_FILE_NOT_FOUND, STR_BMPMAP_ERROR, 0, 0);

   239

		return false;

   240

	}

   241

   242

	BmpInitializeBuffer(&buffer, f);

   243

   244

	if (!BmpReadHeader(&buffer, &info, &data)) {

   245

		ShowErrorMessage(STR_BMPMAP_ERR_IMAGE_TYPE, STR_BMPMAP_ERROR, 0, 0);

   246

		fclose(f);

   247

		BmpDestroyData(&data);

   248

		return false;

   249

	}

   250

   251

	if (map != NULL) {

   252

		if (!BmpReadBitmap(&buffer, &info, &data)) {

   253

			ShowErrorMessage(STR_BMPMAP_ERR_IMAGE_TYPE, STR_BMPMAP_ERROR, 0, 0);

   254

			fclose(f);

   255

			BmpDestroyData(&data);

   256

			return false;

   257

		}

   258

   259

		*map = MallocT<byte>(info.width * info.height);

   260

		if (*map == NULL) {

   261

			ShowErrorMessage(STR_PNGMAP_ERR_MISC, STR_BMPMAP_ERROR, 0, 0);

   262

			fclose(f);

   263

			BmpDestroyData(&data);

   264

			return false;

   265

		}

   266

   267

		ReadHeightmapBMPImageData(*map, &info, &data);

   268

   269

	}

   270

   271

	BmpDestroyData(&data);

   272

   273

	*x = info.width;

   274

	*y = info.height;

   275

   276

	fclose(f);

   277

	return true;

   278

}

   279

   280

/**

   281

 * Converts a given grayscale map to something that fits in OTTD map system

   282

 * and create a map of that data.

   283

 * @param img_width  the with of the image in pixels/tiles

   284

 * @param img_height the height of the image in pixels/tiles

   285

 * @param map        the input map

   286

 */

   287

static void GrayscaleToMapHeights(uint img_width, uint img_height, byte *map)

   288

{

   289

	/* Defines the detail of the aspect ratio (to avoid doubles) */

   290

	const uint num_div = 16384;

   291

   292

	uint width, height;

   293

	uint row, col;

   294

	uint row_pad = 0, col_pad = 0;

   295

	uint img_scale;

   296

	uint img_row, img_col;

   297

	TileIndex tile;

   298

   299

	/* Get map size and calculate scale and padding values */

   300

	switch (_settings_game.game_creation.heightmap_rotation) {

   301

		default: NOT_REACHED();

   302

		case HM_COUNTER_CLOCKWISE:

   303

			width   = MapSizeX();

   304

			height  = MapSizeY();

   305

			break;

   306

		case HM_CLOCKWISE:

   307

			width   = MapSizeY();

   308

			height  = MapSizeX();

   309

			break;

   310

	}

   311

   312

	if ((img_width * num_div) / img_height > ((width * num_div) / height)) {

   313

		/* Image is wider than map - center vertically */

   314

		img_scale = (width * num_div) / img_width;

   315

		row_pad = (1 + height - ((img_height * img_scale) / num_div)) / 2;

   316

	} else {

   317

		/* Image is taller than map - center horizontally */

   318

		img_scale = (height * num_div) / img_height;

   319

		col_pad = (1 + width - ((img_width * img_scale) / num_div)) / 2;

   320

	}

   321

   322

	/* Form the landscape */

   323

	for (row = 0; row < height - 1; row++) {

   324

		for (col = 0; col < width - 1; col++) {

   325

			switch (_settings_game.game_creation.heightmap_rotation) {

   326

				default: NOT_REACHED();

   327

				case HM_COUNTER_CLOCKWISE: tile = TileXY(col, row); break;

   328

				case HM_CLOCKWISE:         tile = TileXY(row, col); break;

   329

			}

   330

   331

			/* Check if current tile is within the 1-pixel map edge or padding regions */

   332

			if ((DistanceFromEdge(tile) <= 1) ||

   333

					(row < row_pad) || (row >= (height - row_pad - 1)) ||

   334

					(col < col_pad) || (col >= (width  - col_pad - 1))) {

   335

				SetTileHeight(tile, 0);

   336

			} else {

   337

				/* Use nearest neighbor resizing to scale map data.

   338

				 *  We rotate the map 45 degrees (counter)clockwise */

   339

				img_row = (((row - row_pad) * num_div) / img_scale);

   340

				switch (_settings_game.game_creation.heightmap_rotation) {

   341

					default: NOT_REACHED();

   342

					case HM_COUNTER_CLOCKWISE:

   343

						img_col = (((width - 1 - col - col_pad) * num_div) / img_scale);

   344

						break;

   345

					case HM_CLOCKWISE:

   346

						img_col = (((col - col_pad) * num_div) / img_scale);

   347

						break;

   348

				}

   349

   350

				assert(img_row < img_height);

   351

				assert(img_col < img_width);

   352

   353

				/* Color scales from 0 to 255, OpenTTD height scales from 0 to 15 */

   354

				SetTileHeight(tile, map[img_row * img_width + img_col] / 16);

   355

			}

   356

			MakeClear(tile, CLEAR_GRASS, 3);

   357

		}

   358

	}

   359

}

   360

   361

/**

   362

 * This function takes care of the fact that land in OpenTTD can never differ

   363

 * more than 1 in height

   364

 */

   365

static void FixSlopes()

   366

{

   367

	uint width, height;

   368

	uint row, col;

   369

	byte current_tile;

   370

   371

	/* Adjust height difference to maximum one horizontal/vertical change. */

   372

	width   = MapSizeX();

   373

	height  = MapSizeY();

   374

   375

	/* Top and left edge */

   376

	for (row = 1; row < height - 2; row++) {

   377

		for (col = 1; col < width - 2; col++) {

   378

			/* Find lowest tile; either the top or left one */

   379

			current_tile = TileHeight(TileXY(col - 1, row)); // top edge

   380

			if (TileHeight(TileXY(col, row - 1)) < current_tile) {

   381

				current_tile = TileHeight(TileXY(col, row - 1)); // left edge

   382

			}

   383

   384

			/* Does the height differ more than one? */

   385

			if (TileHeight(TileXY(col, row)) >= (uint)current_tile + 2) {

   386

				/* Then change the height to be no more than one */

   387

				SetTileHeight(TileXY(col, row), current_tile + 1);

   388

			}

   389

		}

   390

	}

   391

   392

	/* Bottom and right edge */

   393

	for (row = height - 2; row > 0; row--) {

   394

		for (col = width - 2; col > 0; col--) {

   395

			/* Find lowest tile; either the bottom and right one */

   396

			current_tile = TileHeight(TileXY(col + 1, row)); // bottom edge

   397

			if (TileHeight(TileXY(col, row + 1)) < current_tile) {

   398

				current_tile = TileHeight(TileXY(col, row + 1)); // right edge

   399

			}

   400

   401

			/* Does the height differ more than one? */

   402

			if (TileHeight(TileXY(col, row)) >= (uint)current_tile + 2) {

   403

				/* Then change the height to be no more than one */

   404

				SetTileHeight(TileXY(col, row), current_tile + 1);

   405

			}

   406

		}

   407

	}

   408

}

   409

   410

/**

   411

 * Reads the heightmap with the correct file reader

   412

 */

   413

static bool ReadHeightMap(char *filename, uint *x, uint *y, byte **map)

   414

{

   415

	switch (_file_to_saveload.mode) {

   416

		default: NOT_REACHED();

   417

#ifdef WITH_PNG

   418

		case SL_PNG:

   419

			return ReadHeightmapPNG(filename, x, y, map);

   420

#endif /* WITH_PNG */

   421

		case SL_BMP:

   422

			return ReadHeightmapBMP(filename, x, y, map);

   423

	}

   424

}

   425

   426

bool GetHeightmapDimensions(char *filename, uint *x, uint *y)

   427

{

   428

	return ReadHeightMap(filename, x, y, NULL);

   429

}

   430

   431

void LoadHeightmap(char *filename)

   432

{

   433

	uint x, y;

   434

	byte *map = NULL;

   435

   436

	if (!ReadHeightMap(filename, &x, &y, &map)) {

   437

		free(map);

   438

		return;

   439

	}

   440

   441

	GrayscaleToMapHeights(x, y, map);

   442

	free(map);

   443

   444

	FixSlopes();

   445

	MarkWholeScreenDirty();

   446

}

   447

   448

void FlatEmptyWorld(byte tile_height)

   449

{

   450

	uint width, height;

   451

	uint row, col;

   452

   453

	width  = MapSizeX();

   454

	height = MapSizeY();

   455

   456

	for (row = 2; row < height - 2; row++) {

   457

		for (col = 2; col < width - 2; col++) {

   458

			SetTileHeight(TileXY(col, row), tile_height);

   459

		}

   460

	}

   461

   462

	FixSlopes();

   463

	MarkWholeScreenDirty();

   464

}