21 #include "table/strings.h"
33 return ((red * 19595) + (green * 38470) + (blue * 7471)) / 65536;
47 byte gray_palette[256];
48 png_bytep *row_pointers =
nullptr;
49 bool has_palette = png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE;
50 uint channels = png_get_channels(png_ptr, info_ptr);
59 png_get_PLTE(png_ptr, info_ptr, &palette, &palette_size);
60 for (i = 0; i < palette_size && (palette_size != 16 || all_gray); i++) {
61 all_gray &= palette[i].red == palette[i].green && palette[i].red == palette[i].blue;
62 gray_palette[i] =
RGBToGrayscale(palette[i].red, palette[i].green, palette[i].blue);
71 if (palette_size == 16 && !all_gray) {
72 for (i = 0; i < palette_size; i++) {
73 gray_palette[i] = 256 * i / palette_size;
78 row_pointers = png_get_rows(png_ptr, info_ptr);
81 for (x = 0; x < png_get_image_width(png_ptr, info_ptr); x++) {
82 for (y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
83 byte *pixel = &map[y * png_get_image_width(png_ptr, info_ptr) + x];
84 uint x_offset = x * channels;
87 *pixel = gray_palette[row_pointers[y][x_offset]];
88 }
else if (channels == 3) {
90 row_pointers[y][x_offset + 1], row_pointers[y][x_offset + 2]);
92 *pixel = row_pointers[y][x_offset];
106 png_structp png_ptr =
nullptr;
107 png_infop info_ptr =
nullptr;
115 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
nullptr,
nullptr,
nullptr);
116 if (png_ptr ==
nullptr) {
122 info_ptr = png_create_info_struct(png_ptr);
123 if (info_ptr ==
nullptr || setjmp(png_jmpbuf(png_ptr))) {
126 png_destroy_read_struct(&png_ptr, &info_ptr,
nullptr);
130 png_init_io(png_ptr, fp);
134 png_set_packing(png_ptr);
135 png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_STRIP_16,
nullptr);
139 if ((png_get_channels(png_ptr, info_ptr) != 1) && (png_get_channels(png_ptr, info_ptr) != 3) && (png_get_bit_depth(png_ptr, info_ptr) != 8)) {
142 png_destroy_read_struct(&png_ptr, &info_ptr,
nullptr);
146 uint width = png_get_image_width(png_ptr, info_ptr);
147 uint height = png_get_image_height(png_ptr, info_ptr);
150 if ((uint64)width * height >= (
size_t)-1) {
153 png_destroy_read_struct(&png_ptr, &info_ptr,
nullptr);
157 if (map !=
nullptr) {
158 *map = MallocT<byte>(width * height);
166 png_destroy_read_struct(&png_ptr, &info_ptr,
nullptr);
179 byte gray_palette[256];
181 if (data->palette !=
nullptr) {
183 bool all_gray =
true;
187 all_gray &= data->palette[i].r == data->palette[i].g && data->palette[i].r == data->palette[i].b;
188 gray_palette[i] =
RGBToGrayscale(data->palette[i].r, data->palette[i].g, data->palette[i].b);
208 gray_palette[1] = 16;
213 for (y = 0; y < info->
height; y++) {
214 byte *pixel = &map[y * info->
width];
215 byte *bitmap = &data->bitmap[y * info->
width * (info->
bpp == 24 ? 3 : 1)];
217 for (x = 0; x < info->
width; x++) {
218 if (info->
bpp != 24) {
219 *pixel++ = gray_palette[*bitmap++];
241 memset(&data, 0,
sizeof(data));
249 BmpInitializeBuffer(&buffer, f);
251 if (!BmpReadHeader(&buffer, &info, &data)) {
254 BmpDestroyData(&data);
259 if ((uint64)info.
width * info.
height >= (
size_t)-1 / (info.
bpp == 24 ? 3 : 1)) {
262 BmpDestroyData(&data);
266 if (map !=
nullptr) {
267 if (!BmpReadBitmap(&buffer, &info, &data)) {
270 BmpDestroyData(&data);
278 BmpDestroyData(&data);
297 const uint num_div = 16384;
301 uint row_pad = 0, col_pad = 0;
303 uint img_row, img_col;
308 default: NOT_REACHED();
319 if ((img_width * num_div) / img_height > ((width * num_div) / height)) {
321 img_scale = (width * num_div) / img_width;
322 row_pad = (1 + height - ((img_height * img_scale) / num_div)) / 2;
325 img_scale = (height * num_div) / img_height;
326 col_pad = (1 + width - ((img_width * img_scale) / num_div)) / 2;
335 for (row = 0; row < height; row++) {
336 for (col = 0; col < width; col++) {
338 default: NOT_REACHED();
351 img_row = (((row - row_pad) * num_div) / img_scale);
353 default: NOT_REACHED();
355 img_col = (((width - 1 - col - col_pad) * num_div) / img_scale);
358 img_col = (((col - col_pad) * num_div) / img_scale);
362 assert(img_row < img_height);
363 assert(img_col < img_width);
365 uint heightmap_height = map[img_row * img_width + img_col];
367 if (heightmap_height > 0) {
399 for (row = 0; (uint)row < height; row++) {
400 for (col = 0; (uint)col < width; col++) {
421 for (row = height - 1; row >= 0; row--) {
422 for (col = width - 1; col >= 0; col--) {
424 if ((uint)col != width - 1) {
429 if ((uint)row != height - 1) {
513 for (uint row = edge_distance; row <
MapSizeY() - edge_distance; row++) {
514 for (uint col = edge_distance; col <
MapSizeX() - edge_distance; col++) {