Annotation of brogue-ce/src/platform/tiles.c, Revision 1.1
1.1 ! rubenllo 1: #include <math.h>
! 2: #include <stdlib.h>
! 3: #include <SDL_image.h>
! 4: #include "platform.h"
! 5: #include "tiles.h"
! 6:
! 7: #define PI 3.14159265358979323846
! 8:
! 9: #define PNG_WIDTH 2048 // width (px) of the source PNG
! 10: #define PNG_HEIGHT 5568 // height (px) of the source PNG
! 11: #define TILE_WIDTH 128 // width (px) of a single tile in the source PNG
! 12: #define TILE_HEIGHT 232 // height (px) of a single tile in the source PNG
! 13: #define TILE_ROWS 24 // number of rows in the source PNG
! 14: #define TILE_COLS 16 // number of columns in the source PNG
! 15: #define TEXT_X_HEIGHT 100 // height (px) of the 'x' outline
! 16: #define TEXT_BASELINE 46 // height (px) of the blank space below the 'x' outline
! 17: #define MAX_TILE_SIZE 64 // maximum width or height (px) of screen tiles before we switch to linear interpolation
! 18:
! 19:
! 20: // How each tile should be processed:
! 21: // - 's' = stretch: tile stretches to fill the space
! 22: // - 'f' = fit: preserve aspect ratio (but tile can stretch up to 20%)
! 23: // - 't' = text: characters must line up vertically (max. stretch 40%)
! 24: // - '#' = symbols: other Unicode characters (max. stretch 40%)
! 25: static const char TileProcessing[TILE_ROWS][TILE_COLS+1] = {
! 26: "ffffffffffffffff", "ssssssssssssssss", "#t##########t#t#", "tttttttttttt###t",
! 27: "#ttttttttttttttt", "ttttttttttt#####", "#ttttttttttttttt", "ttttttttttt#####",
! 28: "################", "################", "################", "################",
! 29: "tttttttttttttttt", "ttttttt#tttttttt", "tttttttttttttttt", "ttttttt#tttttttt",
! 30: "ffsfsfsffsssssss", "ssfsfsffffffffff", "fffffffffffffsff", "ffffffffffffffff",
! 31: "fsssfffffffffffs", "fsffffffffffffff", "ffffssssffssffff", "ffffsfffffssssff"
! 32: };
! 33:
! 34: typedef struct ScreenTile {
! 35: short foreRed, foreGreen, foreBlue; // foreground color (0..100)
! 36: short backRed, backGreen, backBlue; // background color (0..100)
! 37: short charIndex; // index of the glyph to draw
! 38: short needsRefresh; // true if the tile has changed since the last screen refresh, else false
! 39: } ScreenTile;
! 40:
! 41: static SDL_Window *Win = NULL; // the SDL window
! 42: static SDL_Surface *TilesPNG; // source PNG
! 43: static SDL_Texture *Textures[4]; // textures used by the renderer to draw tiles
! 44: static int numTextures = 0; // how many textures are available in `Textures`
! 45: static int8_t tilePadding[TILE_ROWS][TILE_COLS]; // how many black lines are at the top/bottom of each tile in the source PNG
! 46: static boolean tileEmpty[TILE_ROWS][TILE_COLS]; // true if a tile is completely black in the source PNG, else false
! 47:
! 48: // How much should a corner of a tile be shifted by before its downscaling, to improve its sharpness.
! 49: // The first two dimensions are the tile's coordinates (row and column, both zero-based).
! 50: // The third dimension is either 0 for shifts along the horizontal axis, or 1 for the vertical axis.
! 51: // The fourth dimention is the downscaling operation's target size (width for horizontal axis, height for vertical).
! 52: // The last dimension is 0 for top/left, 1 for bottom/right, 2 for center.
! 53: // The values stored in tileShifts are signed integers. Unit is 1/10th of a pixel.
! 54: static int8_t tileShifts[TILE_ROWS][TILE_COLS][2][MAX_TILE_SIZE][3];
! 55:
! 56: static ScreenTile screenTiles[ROWS][COLS]; // buffer for the expected contents of the screen
! 57: static int baseTileWidth = -1; // width (px) of tiles in the smallest texture (`Textures[0]`)
! 58: static int baseTileHeight = -1; // height (px) of tiles in the smallest texture (`Textures[0]`)
! 59:
! 60:
! 61: int windowWidth = -1; // the SDL window's width (in "screen units", not pixels)
! 62: int windowHeight = -1; // the SDL window's height (in "screen units", not pixels)
! 63: boolean fullScreen = false; // true if the window should be full-screen, else false
! 64: boolean softwareRendering = false; // true if hardware acceleration is disabled (by choice or by force)
! 65:
! 66:
! 67: /// Prints the fatal error message provided by SDL then closes the app.
! 68: static void sdlfatal(char *file, int line) {
! 69: fprintf(stderr, "Fatal SDL error (%s:%d): %s\n", file, line, SDL_GetError());
! 70: exit(1);
! 71: }
! 72:
! 73:
! 74: /// Prints the fatal error message provided by SDL_image then closes the app.
! 75: static void imgfatal(char *file, int line) {
! 76: fprintf(stderr, "Fatal SDL_image error (%s:%d): %s\n", file, line, IMG_GetError());
! 77: exit(1);
! 78: }
! 79:
! 80:
! 81: #if !SDL_VERSION_ATLEAST(2, 0, 5)
! 82:
! 83: SDL_Surface *SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format) {
! 84: Uint32 r, g, b, a;
! 85: if (!SDL_PixelFormatEnumToMasks(format, &depth, &r, &g, &b, &a)) sdlfatal(__FILE__, __LINE__);
! 86: return SDL_CreateRGBSurface(flags, width, height, depth, r, g, b, a);
! 87: }
! 88:
! 89: #endif
! 90:
! 91:
! 92: /// Returns the numbers of black lines at the top and bottom of a given glyph in the source PNG.
! 93: ///
! 94: /// For example, if the glyph has 30 black lines at the top and 40 at the bottom, the function
! 95: /// returns 30 (the least of the two).
! 96: ///
! 97: /// In case the glyph is very small, the function never returns more than TILE_HEIGHT / 4.
! 98: /// This is to avoid drawing the glyph more than twice its size relative to other glyphs
! 99: /// when the window's aspect ratio is very large (super wide).
! 100: ///
! 101: static int getPadding(int row, int column) {
! 102: int padding;
! 103: Uint32 *pixels = TilesPNG->pixels; // each pixel is encoded as 0xffRRGGBB
! 104: for (padding = 0; padding < TILE_HEIGHT / 4; padding++) {
! 105: for (int x = 0; x < TILE_WIDTH; x++) {
! 106: int y1 = padding;
! 107: int y2 = TILE_HEIGHT - padding - 1;
! 108: if (pixels[(x + column * TILE_WIDTH) + (y1 + row * TILE_HEIGHT) * PNG_WIDTH] & 0xffffffU ||
! 109: pixels[(x + column * TILE_WIDTH) + (y2 + row * TILE_HEIGHT) * PNG_WIDTH] & 0xffffffU)
! 110: {
! 111: return padding;
! 112: }
! 113: }
! 114: }
! 115: return padding;
! 116: }
! 117:
! 118:
! 119: /// Tells if a tile is completely empty (black) in the source PNG.
! 120: static boolean isTileEmpty(int row, int column) {
! 121: Uint32 *pixels = TilesPNG->pixels; // each pixel is encoded as 0xffRRGGBB
! 122: for (int y = 0; y < TILE_HEIGHT; y++) {
! 123: for (int x = 0; x < TILE_WIDTH; x++) {
! 124: if (pixels[(x + column * TILE_WIDTH) + (y + row * TILE_HEIGHT) * PNG_WIDTH] & 0xffffffU) {
! 125: return false;
! 126: }
! 127: }
! 128: }
! 129: return true;
! 130: }
! 131:
! 132:
! 133: /// Downscales a tile to the specified size.
! 134: ///
! 135: /// The downscaling is performed in linear color space, rather than in gamma-compressed space which would cause
! 136: /// dimming (average of a black pixel and a white pixel should be 50% grey = 0.5 luminance = 187 sRGB, not 128).
! 137: /// To simplify the computation, we assume a gamma of 2.0.
! 138: ///
! 139: /// The tile is logically split into 16 parts (sliced by 3 vertical lines and 3 horizontal ones), so that:
! 140: ///
! 141: /// - the four corners can be positioned to preserve the tile's aspect ratio,
! 142: /// possibly filling the blank spaces at the top and bottom;
! 143: /// - the top, bottom, left, right, and center areas can be independently aligned
! 144: /// with output pixels to improve sharpness. This is achieved by adding pre-computed
! 145: /// sub-pixel shifts to the target coordinates as we map source pixels to target pixels.
! 146: ///
! 147: /// Some tiles, like walls and doors, always stretch to fill the space regardless of aspect ratio.
! 148: /// Other tiles must preserve aspect ratio, but we allow up to 20% stretch for graphic tiles and
! 149: /// 40% for text tiles.
! 150: ///
! 151: /// For text tiles (letters, digits, punctuation signs), the characters' x-height and baseline
! 152: /// (corresponding to the top and bottom of "x") are pixel-aligned regardless of outlines.
! 153: /// This ensures that all letters neatly line up without jumping up and down.
! 154: /// We also reduce perceived boldness by applying a custom brightness curve;
! 155: /// it makes the text more legible at the smaller sizes.
! 156: ///
! 157: /// Wall tops are diagonal sine waves, approximately 4 pixels apart.
! 158: ///
! 159: /// \param surface the target surface
! 160: /// \param tileWidth width (px) of tiles in the target surface
! 161: /// \param tileHeight height (px) of tiles in the target surface
! 162: /// \param row row (zero-based) on which the tile is located in both the source PNG and the target surface
! 163: /// \param column column (zero-based) in which the tile is located in both the source PNG and the target surface
! 164: /// \param optimizing pass true when optimizing tiles, else false
! 165: /// \return estimated amount of blur in the resulting tile (when optimizing)
! 166: ///
! 167: static double downscaleTile(SDL_Surface *surface, int tileWidth, int tileHeight, int row, int column, boolean optimizing) {
! 168: int8_t noShifts[3] = {0, 0, 0};
! 169: int padding = tilePadding[row][column]; // how much blank spaces there is at the top and bottom of the source tile
! 170: char processing = TileProcessing[row][column]; // how should this tile be processed?
! 171:
! 172: // Size of the area the glyph must fit into
! 173: int fitWidth = max(1, baseTileWidth);
! 174: int fitHeight = max(1, baseTileHeight);
! 175:
! 176: // Number of sine waves that can fit in the tile (for wall tops)
! 177: const int numHorizWaves = max(2, min(6, round(fitWidth * .25)));
! 178: const int numVertWaves = max(2, min(11, round(fitHeight * .25)));
! 179:
! 180: // Size of the downscaled glyph
! 181: int glyphWidth, glyphHeight;
! 182:
! 183: // accumulator for pixel values (linear color space), encoded as
! 184: // 0xCCCCCCCCSSSSSSSS where C is a counter and S is a sum of squares
! 185: uint64_t *values = malloc(tileWidth * tileHeight * sizeof(uint64_t));
! 186: memset(values, 0, tileWidth * tileHeight * sizeof(uint64_t));
! 187: double blur = 0;
! 188:
! 189: // if the tile is empty, we can skip the downscaling
! 190: if (tileEmpty[row][column]) goto downscaled;
! 191:
! 192: // decide how large we can draw the glyph
! 193: if (processing == 's' || optimizing) {
! 194: // stretch
! 195: glyphWidth = fitWidth = tileWidth;
! 196: glyphHeight = fitHeight = tileHeight;
! 197: } else if (processing == 'f') {
! 198: // fit
! 199: int hi = fitHeight * TILE_HEIGHT / (TILE_HEIGHT - 2 * padding);
! 200: int lo = max(1, min(fitHeight, round(1.2 * fitWidth * TILE_HEIGHT / TILE_WIDTH)));
! 201: glyphHeight = max(lo, min(hi, round((double)fitWidth * TILE_HEIGHT / TILE_WIDTH)));
! 202: glyphWidth = max(1, min(fitWidth, round(1.2 * glyphHeight * TILE_WIDTH / TILE_HEIGHT)));
! 203: } else {
! 204: // text
! 205: glyphWidth = max(1, min(fitWidth, round(1.4 * fitHeight * TILE_WIDTH / TILE_HEIGHT)));
! 206: glyphHeight = max(1, min(fitHeight, round(1.4 * fitWidth * TILE_HEIGHT / TILE_WIDTH)));
! 207: }
! 208:
! 209: // map source pixels to target pixels...
! 210: int scaledX[TILE_WIDTH], scaledY[TILE_HEIGHT];
! 211: int stop0, stop1, stop2, stop3, stop4;
! 212: double map0, map1, map2, map3, map4;
! 213: int8_t *shifts;
! 214:
! 215: // ... horizontally:
! 216:
! 217: // horizontal coordinates on the source tile for the left border (stop0), 3 taps (stop1, 2, 3), and right border (stop4)
! 218: stop0 = 0;
! 219: stop1 = TILE_WIDTH / 5; // 20%
! 220: stop2 = TILE_WIDTH / 2; // 50%
! 221: stop3 = TILE_WIDTH * 4/5; // 80%
! 222: stop4 = TILE_WIDTH;
! 223:
! 224: // corresponding coordinates on the target tile, taking into account centering and sub-pixel positioning
! 225: shifts = (glyphWidth > MAX_TILE_SIZE ? noShifts : tileShifts[row][column][0][glyphWidth - 1]);
! 226: map0 = (fitWidth - glyphWidth + (shifts[0] + shifts[1] < 0 ? 1 : 0)) / 2;
! 227: map1 = map0 + glyphWidth * (double)(stop1 - stop0) / (stop4 - stop0) + shifts[0] * 0.1;
! 228: map2 = map0 + glyphWidth * (double)(stop2 - stop0) / (stop4 - stop0) + shifts[2] * 0.1;
! 229: map3 = map0 + glyphWidth * (double)(stop3 - stop0) / (stop4 - stop0) + shifts[1] * 0.1;
! 230: map4 = map0 + glyphWidth;
! 231:
! 232: // now we can interpolate the horizontal coordinates for all pixels
! 233: for (int x = stop0; x < stop1; x++) scaledX[x] = map0 + (map1 - map0) * (x - stop0) / (stop1 - stop0);
! 234: for (int x = stop1; x < stop2; x++) scaledX[x] = map1 + (map2 - map1) * (x - stop1) / (stop2 - stop1);
! 235: for (int x = stop2; x < stop3; x++) scaledX[x] = map2 + (map3 - map2) * (x - stop2) / (stop3 - stop2);
! 236: for (int x = stop3; x < stop4; x++) scaledX[x] = map3 + (map4 - map3) * (x - stop3) / (stop4 - stop3);
! 237:
! 238: // ... vertically:
! 239:
! 240: if (processing == 't') {
! 241: // vertical coordinates on the source tile for the top edge (stop0), stem (stop1), "x" (stop2, stop3), and bottom edge (stop4)
! 242: stop4 = TILE_HEIGHT;
! 243: stop3 = stop4 - TEXT_BASELINE;
! 244: stop2 = stop3 - TEXT_X_HEIGHT;
! 245: stop1 = stop2 / 3;
! 246: stop0 = 0;
! 247: } else {
! 248: // vertical coordinates on the source tile for the top edge (stop0), 3 taps (stop1, 2, 3), and bottom edge (stop4)
! 249: stop0 = 0;
! 250: stop1 = TILE_HEIGHT / 5; // 20%
! 251: stop2 = TILE_HEIGHT / 2; // 50%
! 252: stop3 = TILE_HEIGHT * 4/5; // 80%
! 253: stop4 = TILE_HEIGHT;
! 254: }
! 255:
! 256: // corresponding coordinates on the target tile, taking into account centering
! 257: map0 = (fitHeight - glyphHeight) / 2;
! 258: map1 = map0 + glyphHeight * (double)(stop1 - stop0) / (stop4 - stop0);
! 259: map2 = map0 + glyphHeight * (double)(stop2 - stop0) / (stop4 - stop0);
! 260: map3 = map0 + glyphHeight * (double)(stop3 - stop0) / (stop4 - stop0);
! 261: map4 = map0 + glyphHeight;
! 262:
! 263: // for text tiles, we must exactly align stops #2 and #3 with output pixels
! 264: if (processing == 't') {
! 265: map3 += round(map2) - map2;
! 266: map2 = round(map2);
! 267: map3 = max(map2 + 1, round(map3));
! 268: map1 = map0 + (map2 - map0) / 3;
! 269: }
! 270:
! 271: // now add sub-pixel positioning (for text tiles, we have shifts[1] == shifts[2] == 0)
! 272: shifts = (glyphHeight > MAX_TILE_SIZE ? noShifts : tileShifts[row][column][1][glyphHeight - 1]);
! 273: map1 += shifts[0] * 0.1;
! 274: map2 += shifts[2] * 0.1;
! 275: map3 += shifts[1] * 0.1;
! 276:
! 277: // finally we can interpolate the vertical coordinates for all pixels
! 278: for (int y = 0; y < stop0; y++) scaledY[y] = -1; // not mapped (can happen with fitted tiles)
! 279: for (int y = stop0; y < stop1; y++) scaledY[y] = map0 + (map1 - map0) * (y - stop0) / (stop1 - stop0);
! 280: for (int y = stop1; y < stop2; y++) scaledY[y] = map1 + (map2 - map1) * (y - stop1) / (stop2 - stop1);
! 281: for (int y = stop2; y < stop3; y++) scaledY[y] = map2 + (map3 - map2) * (y - stop2) / (stop3 - stop2);
! 282: for (int y = stop3; y < stop4; y++) scaledY[y] = map3 + (map4 - map3) * (y - stop3) / (stop4 - stop3);
! 283: for (int y = stop4; y < TILE_HEIGHT; y++) scaledY[y] = -1; // not mapped (can happen with fitted tiles)
! 284:
! 285: // downscale source tile to accumulator
! 286: for (int y0 = 0; y0 < TILE_HEIGHT; y0++) {
! 287: int y1 = scaledY[y0];
! 288: if (y1 < 0 || y1 >= tileHeight) continue;
! 289: uint64_t *dst = &values[y1 * tileWidth];
! 290: Uint32 *src = TilesPNG->pixels; // each pixel is encoded as 0xffRRGGBB
! 291: src += (column * TILE_WIDTH) + (row * TILE_HEIGHT + y0) * PNG_WIDTH;
! 292: for (int x0 = 0; x0 < TILE_WIDTH; x0++) {
! 293: uint64_t value = src[x0] & 0xffU;
! 294: dst[scaledX[x0]] += (value * value) | 0x100000000U; // (gamma = 2.0, count = 1)
! 295: }
! 296: // interpolate skipped lines, if any
! 297: if (y1 >= 2 && scaledY[y0 - 1] == y1 - 2) {
! 298: for (int x1 = 0; x1 < tileWidth; x1++) {
! 299: dst[x1 - tileWidth] = dst[x1 - 2*tileWidth] + dst[x1];
! 300: }
! 301: }
! 302: }
! 303: downscaled:
! 304:
! 305: // procedural wall tops: diagonal sine waves
! 306: if ((row == 16 && column == 2 || row == 21 && column == 1 || row == 22 && column == 4) && !optimizing) {
! 307: for (int y = 0; y < tileHeight; y++) {
! 308: if (row != 21 && (y > tileHeight / 2 || (values[y * tileWidth] & 0xffffffffU))) break;
! 309: for (int x = 0; x < tileWidth; x++) {
! 310: double value = sin(2. * PI * ((double)x / tileWidth * numHorizWaves
! 311: + (double)y / tileHeight * numVertWaves)) / 2. + 0.5;
! 312: values[y * tileWidth + x] = (uint64_t)round(255 * 255 * value * value) | 0x100000000U;
! 313: }
! 314: }
! 315: }
! 316:
! 317: // convert accumulator to image transparency
! 318: for (int y = 0; y < tileHeight; y++) {
! 319: Uint32 *pixel = surface->pixels; // each pixel is encoded as 0xAARRGGBB
! 320: pixel += (column * tileWidth) + (row * tileHeight + y) * surface->w;
! 321: for (int x = 0; x < tileWidth; x++) {
! 322: uint64_t value = values[y * tileWidth + x];
! 323:
! 324: // average light intensity (linear scale, 0 .. 255*255)
! 325: value = ((value >> 32) ? (value & 0xffffffffU) / (value >> 32) : 0);
! 326:
! 327: // metric for "blurriness": black (0) and white (255*255) pixels count for 0, gray pixels for 1
! 328: if (optimizing) blur += sin(PI/(255*255) * value);
! 329:
! 330: // make text look less bold, at the cost of accuracy
! 331: if (processing == 't' || processing == '#') {
! 332: value = (value < 255*255/2 ? value / 2 : value * 3/2 - 255*255/2);
! 333: }
! 334:
! 335: // opacity (gamma-compressed, 0 .. 255)
! 336: uint32_t alpha = (value == 0 ? 0 : value > 64770 ? 255 : round(sqrt(value)));
! 337:
! 338: *pixel++ = (alpha << 24) | 0xffffffU;
! 339: }
! 340: }
! 341:
! 342: free(values);
! 343: return blur; // (used by the optimizer)
! 344: }
! 345:
! 346:
! 347: /// Finds the best possible sub-pixel alignments of tiles for their downscaling at every possible size.
! 348: /// Results are recorded into `tileShifts`.
! 349: ///
! 350: /// This is a slow function (takes ~2 minutes) so the results are saved to disk and reloaded when Brogue starts.
! 351: /// After you modify the PNG, you should also delete "tiles.bin" and run Brogue so that the new tiles get optimized.
! 352: static void optimizeTiles() {
! 353: SDL_Window *window = SDL_CreateWindow("Brogue", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 400, 300, 0);
! 354:
! 355: for (int row = 0; row < TILE_ROWS; row++) {
! 356: for (int column = 0; column < TILE_COLS; column++) {
! 357: if (tileEmpty[row][column]) continue;
! 358: char processing = TileProcessing[row][column];
! 359:
! 360: // show what we are doing
! 361: char title[100];
! 362: sprintf(title, "Brogue - Optimizing tile %d / %d ...\n", row * TILE_COLS + column + 1, TILE_ROWS * TILE_COLS);
! 363: SDL_SetWindowTitle(window, title);
! 364: SDL_Surface *winSurface = SDL_GetWindowSurface(window);
! 365: if (!winSurface) sdlfatal(__FILE__, __LINE__);
! 366: if (SDL_BlitSurface(TilesPNG, &(SDL_Rect){.x=column*TILE_WIDTH, .y=row*TILE_HEIGHT, .w=TILE_WIDTH, .h=TILE_HEIGHT},
! 367: winSurface, &(SDL_Rect){.x=0, .y=0, .w=TILE_WIDTH, .h=TILE_HEIGHT}) < 0) sdlfatal(__FILE__, __LINE__);
! 368: if (SDL_UpdateWindowSurface(window) < 0) sdlfatal(__FILE__, __LINE__);
! 369:
! 370: // horizontal shifts
! 371: baseTileHeight = MAX_TILE_SIZE;
! 372: for (baseTileWidth = 5; baseTileWidth <= MAX_TILE_SIZE; baseTileWidth++) {
! 373: int8_t *shifts = tileShifts[row][column][0][baseTileWidth - 1];
! 374: SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(0, baseTileWidth * TILE_COLS, baseTileHeight * TILE_ROWS, 32, SDL_PIXELFORMAT_ARGB8888);
! 375: if (!surface) sdlfatal(__FILE__, __LINE__);
! 376:
! 377: for (int i = 0; i < 3; i++) {
! 378: for (int idx = 0; idx < (processing == 't' || processing == '#' ? 2 : 3); idx++) {
! 379: double bestResult = 1e20;
! 380: int8_t bestShift = 0;
! 381: int8_t midShift = (idx == 2 ? (shifts[0] + shifts[1]) / 2 : 0);
! 382: for (int8_t shift = midShift - 5; shift <= midShift + 5; shift++) {
! 383: shifts[idx] = shift;
! 384: if (processing == 't' || processing == '#') {
! 385: shifts[2] = (shifts[0] + shifts[1]) / 2;
! 386: }
! 387: double blur = downscaleTile(surface, baseTileWidth, baseTileHeight, row, column, true);
! 388: if (blur < bestResult) {
! 389: bestResult = blur;
! 390: bestShift = shift;
! 391: }
! 392: }
! 393: shifts[idx] = bestShift;
! 394: if (processing == 't' || processing == '#') {
! 395: shifts[2] = (shifts[0] + shifts[1]) / 2;
! 396: }
! 397: }
! 398: }
! 399:
! 400: SDL_FreeSurface(surface);
! 401: }
! 402:
! 403: // vertical shifts
! 404: baseTileWidth = MAX_TILE_SIZE;
! 405: for (baseTileHeight = 7; baseTileHeight <= MAX_TILE_SIZE; baseTileHeight++) {
! 406: int8_t *shifts = tileShifts[row][column][1][baseTileHeight - 1];
! 407: SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(0, baseTileWidth * TILE_COLS, baseTileHeight * TILE_ROWS, 32, SDL_PIXELFORMAT_ARGB8888);
! 408: if (!surface) sdlfatal(__FILE__, __LINE__);
! 409:
! 410: for (int i = 0; i < 3; i++) {
! 411: for (int idx = 0; idx < (processing == 't' ? 1 : 3); idx++) {
! 412: double bestResult = 1e20;
! 413: int8_t bestShift = 0;
! 414: int8_t midShift = (idx == 2 ? (shifts[0] + shifts[1]) / 2 : 0);
! 415: for (int8_t shift = midShift - 5; shift <= midShift + 5; shift++) {
! 416: shifts[idx] = shift;
! 417: double blur = downscaleTile(surface, baseTileWidth, baseTileHeight, row, column, true);
! 418: if (blur < bestResult) {
! 419: bestResult = blur;
! 420: bestShift = shift;
! 421: }
! 422: }
! 423: shifts[idx] = bestShift;
! 424: }
! 425: }
! 426:
! 427: SDL_FreeSurface(surface);
! 428: }
! 429: }
! 430: }
! 431: SDL_DestroyWindow(window);
! 432: }
! 433:
! 434:
! 435: /// Loads the PNG and analyses it.
! 436: void initTiles() {
! 437:
! 438: // load the large PNG
! 439: char filename[BROGUE_FILENAME_MAX];
! 440: sprintf(filename, "%s/assets/tiles.png", dataDirectory);
! 441: SDL_Surface *image = IMG_Load(filename);
! 442: if (!image) imgfatal(__FILE__, __LINE__);
! 443: TilesPNG = SDL_ConvertSurfaceFormat(image, SDL_PIXELFORMAT_ARGB8888, 0);
! 444: if (!TilesPNG) sdlfatal(__FILE__, __LINE__);
! 445: SDL_FreeSurface(image);
! 446:
! 447: // measure padding
! 448: for (int row = 0; row < TILE_ROWS; row++) {
! 449: for (int column = 0; column < TILE_COLS; column++) {
! 450: tileEmpty[row][column] = isTileEmpty(row, column);
! 451: tilePadding[row][column] = (TileProcessing[row][column] == 'f' ? getPadding(row, column) : 0);
! 452: }
! 453: }
! 454:
! 455: // load shifts
! 456: sprintf(filename, "%s/assets/tiles.bin", dataDirectory);
! 457: FILE *file = fopen(filename, "rb");
! 458: if (file) {
! 459: fread(tileShifts, 1, sizeof(tileShifts), file);
! 460: fclose(file);
! 461: } else {
! 462: optimizeTiles();
! 463: file = fopen(filename, "wb");
! 464: fwrite(tileShifts, 1, sizeof(tileShifts), file);
! 465: fclose(file);
! 466: }
! 467: }
! 468:
! 469:
! 470: /// Creates the textures to fit a specific output size
! 471: /// (which is equal to the window size on standard DPI displays, but can be larger on HiDPI).
! 472: ///
! 473: /// We build up to 4 textures, with different tile sizes. Each texture has all the tiles on it.
! 474: /// The first texture (`Textures[0]`) is always present, and is always the smallest of the bunch.
! 475: ///
! 476: /// The reason for having tiles of different sizes ready to be drawn on screen is that the window
! 477: /// width is usually not a multiple of 100 (the `COLS` constant), and height not a multiple of 34
! 478: /// (`ROWS`). Since tiles must have integer dimensions, that means some tiles must be larger by
! 479: /// 1 pixel than others, so that we can cover the window without black padding on the sides nor
! 480: /// columns/rows of blank pixels between tiles.
! 481: ///
! 482: /// If the window is so large that tiles would have to be over 64x64 pixels, we generate a single, large
! 483: /// texture instead of four and use it for all tiles, allowing the renderer to do some linear interpolation.
! 484: ///
! 485: /// To ensure compatibility with older OpenGL drivers, texture dimensions are always powers of 2.
! 486: ///
! 487: /// \param outputWidth renderer's output width
! 488: /// \param outputHeight renderer's output height
! 489: ///
! 490: static void createTextures(SDL_Renderer *renderer, int outputWidth, int outputHeight) {
! 491:
! 492: // choose tile size
! 493: double tileAspectRatio = (double)(outputWidth * ROWS) / (outputHeight * COLS);
! 494: int newBaseTileWidth = max(1, outputWidth / COLS);
! 495: int newBaseTileHeight = max(1, outputHeight / ROWS);
! 496: if (newBaseTileWidth >= MAX_TILE_SIZE || newBaseTileHeight >= MAX_TILE_SIZE) {
! 497: newBaseTileWidth = max(1, min(TILE_WIDTH, round(TILE_HEIGHT * tileAspectRatio)));
! 498: newBaseTileHeight = max(1, min(TILE_HEIGHT, round(TILE_WIDTH / tileAspectRatio)));
! 499: }
! 500:
! 501: // if tile size has not changed, we don't need to rebuild the tiles
! 502: if (baseTileWidth == newBaseTileWidth && baseTileHeight == newBaseTileHeight) {
! 503: return;
! 504: }
! 505:
! 506: baseTileWidth = newBaseTileWidth;
! 507: baseTileHeight = newBaseTileHeight;
! 508:
! 509: // destroy the old textures
! 510: for (int i = 0; i < 4; i++) {
! 511: if (Textures[i]) SDL_DestroyTexture(Textures[i]);
! 512: Textures[i] = NULL;
! 513: }
! 514:
! 515: // choose the number of textures
! 516: if (baseTileWidth >= MAX_TILE_SIZE || baseTileHeight >= MAX_TILE_SIZE) {
! 517: numTextures = 1;
! 518: SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
! 519: } else {
! 520: numTextures = 4;
! 521: SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "nearest");
! 522: }
! 523:
! 524: // The original image will be resized to 4 possible sizes:
! 525: // - Textures[0]: tiles are W x H pixels
! 526: // - Textures[1]: tiles are (W+1) x H pixels
! 527: // - Textures[2]: tiles are W x (H+1) pixels
! 528: // - Textures[3]: tiles are (W+1) x (H+1) pixels
! 529:
! 530: for (int i = 0; i < numTextures; i++) {
! 531:
! 532: // choose dimensions
! 533: int tileWidth = baseTileWidth + (i == 1 || i == 3 ? 1 : 0);
! 534: int tileHeight = baseTileHeight + (i == 2 || i == 3 ? 1 : 0);
! 535: int surfaceWidth = 1, surfaceHeight = 1;
! 536: while (surfaceWidth < tileWidth * TILE_COLS) surfaceWidth *= 2;
! 537: while (surfaceHeight < tileHeight * TILE_ROWS) surfaceHeight *= 2;
! 538:
! 539: // downscale the tiles
! 540: SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(0, surfaceWidth, surfaceHeight, 32, SDL_PIXELFORMAT_ARGB8888);
! 541: if (!surface) sdlfatal(__FILE__, __LINE__);
! 542: for (int row = 0; row < TILE_ROWS; row++) {
! 543: for (int column = 0; column < TILE_COLS; column++) {
! 544: downscaleTile(surface, tileWidth, tileHeight, row, column, false);
! 545: }
! 546: }
! 547:
! 548: // convert to texture
! 549: Textures[i] = SDL_CreateTextureFromSurface(renderer, surface);
! 550: if (!Textures[i]) sdlfatal(__FILE__, __LINE__);
! 551: if (SDL_SetTextureBlendMode(Textures[i], SDL_BLENDMODE_BLEND) < 0) sdlfatal(__FILE__, __LINE__);
! 552: SDL_FreeSurface(surface);
! 553: }
! 554: }
! 555:
! 556:
! 557: /// Updates the screen buffer.
! 558: ///
! 559: /// \param row row on screen (between 0 and ROWS-1)
! 560: /// \param column column on screen (between 0 and COLS-1)
! 561: /// \param charIndex glyph number (e.g 48 for "@", 281 for Dragon)
! 562: /// \param foreRed red component of the foreground color (0..100)
! 563: /// \param foreGreen green component of the foreground color (0..100)
! 564: /// \param foreBlue blue component of the foreground color (0..100)
! 565: /// \param backRed red component of the background color (0..100)
! 566: /// \param backGreen green component of the background color (0..100)
! 567: /// \param backBlue blue component of the background color (0..100)
! 568: ///
! 569: void updateTile(int row, int column, short charIndex,
! 570: short foreRed, short foreGreen, short foreBlue,
! 571: short backRed, short backGreen, short backBlue)
! 572: {
! 573: screenTiles[row][column] = (ScreenTile){
! 574: .foreRed = foreRed,
! 575: .foreGreen = foreGreen,
! 576: .foreBlue = foreBlue,
! 577: .backRed = backRed,
! 578: .backGreen = backGreen,
! 579: .backBlue = backBlue,
! 580: .charIndex = charIndex,
! 581: .needsRefresh = 1
! 582: };
! 583: }
! 584:
! 585:
! 586: /// Draws everything on screen.
! 587: ///
! 588: /// OpenGL drivers don't like alternating between different textures too much, so we
! 589: /// first draw the background colors then do 4 passes over the tiles, one pass per texture.
! 590: ///
! 591: /// Some video drivers are quite inefficient, notably in virtual machines, so
! 592: /// there is a new `--no-gpu` command-line parameter to disable hardware acceleration.
! 593: /// The software renderer does not support HiDPI, though.
! 594: ///
! 595: /// To improve performance of the software renderer, we don't redraw the whole screen but
! 596: /// only the tiles that have changed recently (which is tracked with ScreenTile::needsRefresh).
! 597: /// This works because, unlike the accelerated renderers, the software renderer draws on a
! 598: /// single surface and doesn't do double-buffering.
! 599: ///
! 600: void updateScreen() {
! 601: if (!Win) return;
! 602:
! 603: SDL_Renderer *renderer = SDL_GetRenderer(Win);
! 604: if (!renderer) {
! 605: renderer = SDL_CreateRenderer(Win, -1, (softwareRendering ? SDL_RENDERER_SOFTWARE : 0));
! 606: if (!renderer) sdlfatal(__FILE__, __LINE__);
! 607:
! 608: if (SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE) < 0) sdlfatal(__FILE__, __LINE__);
! 609:
! 610: // see if we ended up using the software renderer or not
! 611: SDL_RendererInfo info;
! 612: if (SDL_GetRendererInfo(renderer, &info) < 0) sdlfatal(__FILE__, __LINE__);
! 613: softwareRendering = (strcmp(info.name, "software") == 0);
! 614: }
! 615:
! 616: int outputWidth, outputHeight;
! 617: if (SDL_GetRendererOutputSize(renderer, &outputWidth, &outputHeight) < 0) sdlfatal(__FILE__, __LINE__);
! 618: if (outputWidth == 0 || outputHeight == 0) return;
! 619:
! 620: createTextures(renderer, outputWidth, outputHeight);
! 621:
! 622: if (!softwareRendering) {
! 623: // black out the frame (double-buffering invalidated it)
! 624: if (SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0) < 0) sdlfatal(__FILE__, __LINE__);
! 625: if (SDL_RenderClear(renderer) < 0) sdlfatal(__FILE__, __LINE__);
! 626: }
! 627:
! 628: // To please the OpenGL renderer, we'll proceed in 5 steps:
! 629: // -1. background colors
! 630: // 0. Textures[0]
! 631: // 1. Textures[1]
! 632: // 2. Textures[2]
! 633: // 3. Textures[3]
! 634:
! 635: for (int step = -1; step < numTextures; step++) {
! 636:
! 637: for (int x = 0; x < COLS; x++) {
! 638: int tileWidth = ((x+1) * outputWidth / COLS) - (x * outputWidth / COLS);
! 639: if (tileWidth == 0) continue;
! 640:
! 641: for (int y = 0; y < ROWS; y++) {
! 642: int tileHeight = ((y+1) * outputHeight / ROWS) - (y * outputHeight / ROWS);
! 643: if (tileHeight == 0) continue;
! 644:
! 645: ScreenTile *tile = &screenTiles[y][x];
! 646: if (softwareRendering && !tile->needsRefresh) {
! 647: continue; // software rendering does not use double-buffering, so the tile is still on screen
! 648: }
! 649:
! 650: if (step < 0) {
! 651: if (!softwareRendering && tile->backRed == 0 && tile->backGreen == 0 && tile->backBlue == 0) {
! 652: continue; // SDL_RenderClear already painted everything black
! 653: }
! 654:
! 655: SDL_Rect dest;
! 656: dest.w = tileWidth;
! 657: dest.h = tileHeight;
! 658: dest.x = x * outputWidth / COLS;
! 659: dest.y = y * outputHeight / ROWS;
! 660:
! 661: // paint the background
! 662: if (SDL_SetRenderDrawColor(renderer,
! 663: round(2.55 * tile->backRed),
! 664: round(2.55 * tile->backGreen),
! 665: round(2.55 * tile->backBlue), 255) < 0) sdlfatal(__FILE__, __LINE__);
! 666: if (SDL_RenderFillRect(renderer, &dest) < 0) sdlfatal(__FILE__, __LINE__);
! 667:
! 668: } else {
! 669: int textureIndex = (numTextures < 4 ? 0 : (tileWidth > baseTileWidth ? 1 : 0) + (tileHeight > baseTileHeight ? 2 : 0));
! 670: if (step != textureIndex) {
! 671: continue; // this tile uses another texture and gets painted at another step
! 672: }
! 673:
! 674: int tileRow = tile->charIndex / 16;
! 675: int tileColumn = tile->charIndex % 16;
! 676:
! 677: if (tileEmpty[tileRow][tileColumn]
! 678: && !(tileRow == 21 && tileColumn == 1)) { // wall top (procedural)
! 679: continue; // there is nothing to draw
! 680: }
! 681:
! 682: SDL_Rect src;
! 683: src.w = baseTileWidth + (step == 1 || step == 3 ? 1 : 0);
! 684: src.h = baseTileHeight + (step == 2 || step == 3 ? 1 : 0);
! 685: src.x = src.w * tileColumn;
! 686: src.y = src.h * tileRow;
! 687:
! 688: SDL_Rect dest;
! 689: dest.w = tileWidth;
! 690: dest.h = tileHeight;
! 691: dest.x = x * outputWidth / COLS;
! 692: dest.y = y * outputHeight / ROWS;
! 693:
! 694: // blend the foreground
! 695: if (SDL_SetTextureColorMod(Textures[step],
! 696: round(2.55 * tile->foreRed),
! 697: round(2.55 * tile->foreGreen),
! 698: round(2.55 * tile->foreBlue)) < 0) sdlfatal(__FILE__, __LINE__);
! 699: if (SDL_RenderCopy(renderer, Textures[step], &src, &dest) < 0) sdlfatal(__FILE__, __LINE__);
! 700: }
! 701: }
! 702: }
! 703: }
! 704:
! 705: SDL_RenderPresent(renderer);
! 706:
! 707: // the screen is now up to date
! 708: for (int y = 0; y < ROWS; y++) {
! 709: for (int x = 0; x < COLS; x++) {
! 710: screenTiles[y][x].needsRefresh = 0;
! 711: }
! 712: }
! 713: }
! 714:
! 715:
! 716: /*
! 717: Creates or resizes the game window with the currently loaded font.
! 718: */
! 719: void resizeWindow(int width, int height) {
! 720:
! 721: SDL_DisplayMode mode;
! 722: if (SDL_GetCurrentDisplayMode(0, &mode) < 0) sdlfatal(__FILE__, __LINE__);
! 723:
! 724: // 70% of monitor width by default, with height following 16:10 aspect ratio
! 725: if (width < 0) width = mode.w * 7/10;
! 726: if (height < 0) height = width * 10/16;
! 727:
! 728: // go to fullscreen mode if the window is as big as the screen
! 729: if (width >= mode.w && height >= mode.h) fullScreen = true;
! 730:
! 731: if (Win == NULL) {
! 732: // create the window
! 733: Win = SDL_CreateWindow("Brogue",
! 734: SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height,
! 735: SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | (fullScreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
! 736: if (!Win) sdlfatal(__FILE__, __LINE__);
! 737:
! 738: // set its icon
! 739: char filename[BROGUE_FILENAME_MAX];
! 740: sprintf(filename, "%s/assets/icon.png", dataDirectory);
! 741: SDL_Surface *icon = IMG_Load(filename);
! 742: if (!icon) imgfatal(__FILE__, __LINE__);
! 743: SDL_SetWindowIcon(Win, icon);
! 744: SDL_FreeSurface(icon);
! 745: }
! 746:
! 747: if (fullScreen) {
! 748: if (!(SDL_GetWindowFlags(Win) & SDL_WINDOW_FULLSCREEN_DESKTOP)) {
! 749: // switch to fullscreen mode
! 750: if (SDL_SetWindowFullscreen(Win, SDL_WINDOW_FULLSCREEN_DESKTOP) < 0) sdlfatal(__FILE__, __LINE__);
! 751: }
! 752: } else {
! 753: if (SDL_GetWindowFlags(Win) & SDL_WINDOW_FULLSCREEN_DESKTOP) {
! 754: // switch to windowed mode
! 755: if (SDL_SetWindowFullscreen(Win, 0) < 0) sdlfatal(__FILE__, __LINE__);
! 756: } else {
! 757: // what is the current size?
! 758: SDL_GetWindowSize(Win, &windowWidth, &windowHeight);
! 759: if (windowWidth != width || windowHeight != height) {
! 760: // resize the window
! 761: SDL_SetWindowSize(Win, width, height);
! 762: SDL_RestoreWindow(Win);
! 763: }
! 764: }
! 765: }
! 766:
! 767: SDL_GetWindowSize(Win, &windowWidth, &windowHeight);
! 768: refreshScreen();
! 769: updateScreen();
! 770: }
! 771:
! 772:
! 773: SDL_Surface *captureScreen() {
! 774: if (!Win) return NULL;
! 775:
! 776: // get the renderer
! 777: SDL_Renderer *renderer = SDL_GetRenderer(Win);
! 778: if (!renderer) return NULL;
! 779:
! 780: // get its size
! 781: int outputWidth, outputHeight;
! 782: if (SDL_GetRendererOutputSize(renderer, &outputWidth, &outputHeight) < 0) sdlfatal(__FILE__, __LINE__);
! 783: if (outputWidth == 0 || outputHeight == 0) return NULL;
! 784:
! 785: // take a screenshot
! 786: SDL_Surface *screenshot = SDL_CreateRGBSurfaceWithFormat(0, outputWidth, outputHeight, 32, SDL_PIXELFORMAT_ARGB8888);
! 787: if (!screenshot) sdlfatal(__FILE__, __LINE__);
! 788: if (SDL_RenderReadPixels(renderer, NULL, SDL_PIXELFORMAT_ARGB8888, screenshot->pixels, outputWidth * 4) < 0) sdlfatal(__FILE__, __LINE__);
! 789: return screenshot;
! 790: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tiles.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / platform