diff --git a/.travis.yml b/.travis.yml index bbcb7721..d3cce374 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,6 +19,6 @@ before_script: fi; } script: - - make + - make -j2 - make compare - check_status diff --git a/INSTALL.md b/INSTALL.md index f31f22ee..c708a013 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -1,6 +1,6 @@ # Linux - sudo apt-get install make git python + sudo apt-get install make git gcc sudo apt-get install byacc flex pkg-config libpng-dev git clone https://github.com/rednex/rgbds @@ -8,7 +8,7 @@ sudo make install cd .. - git clone --recursive https://github.com/pret/pokered + git clone https://github.com/pret/pokered cd pokered To build **pokered.gbc** and **pokeblue.gbc**: @@ -30,27 +30,31 @@ Then in **Terminal**, run: xcode-select --install brew install rgbds - git clone --recursive https://github.com/pret/pokered + git clone https://github.com/pret/pokered cd pokered +To build **pokered.gbc** and **pokeblue.gbc**: + make # Windows -To build on Windows, use [**Cygwin**](http://cygwin.com/install.html) (64-bit). Use the default settings. +Download [**Cygwin**](http://cygwin.com/install.html): **setup-x86_64.exe** for 64-bit Windows, **setup-x86.exe** for 32-bit. + +Run setup and leave the default settings. At "Select Packages", choose to install the following: -In the installer, select the following packages: - `make` - `git` -- `python` +- `gcc-core` -Then download [**rgbds**](https://github.com/bentley/rgbds/releases). -Extract the archive. Inside should be `rgbasm.exe`, `rgblink.exe`, `rgbfix.exe`, `rgbgfx.exe` and some `.dll` files. Put each file in `C:\cygwin64\usr\local\bin\`. If your Cygwin installation directory differs, ensure the `bin` directory is present in the PATH variable. +Then download [**rgbds**](https://github.com/rednex/rgbds/releases/): the latest **win64.tar.gz** or **win32.tar.gz** release. Extract it and put all the `exe` and `dll` files individually in **C:\cygwin64\usr\local\bin**. -In the **Cygwin terminal**: +In the **Cygwin terminal**, enter these commands: - git clone --recursive https://github.com/pret/pokered + git clone https://github.com/pret/pokered cd pokered +To build **pokered.gbc** and **pokeblue.gbc**: + make diff --git a/Makefile b/Makefile index d0d3c011..dd266f23 100644 --- a/Makefile +++ b/Makefile @@ -1,20 +1,13 @@ -PYTHON := python -MD5 := md5sum -c --quiet - -2bpp := $(PYTHON) extras/pokemontools/gfx.py 2bpp -1bpp := $(PYTHON) extras/pokemontools/gfx.py 1bpp -pic := $(PYTHON) extras/pokemontools/pic.py compress -includes := $(PYTHON) extras/pokemontools/scan_includes.py +MD5 := md5sum -c pokered_obj := audio_red.o main_red.o text_red.o wram_red.o pokeblue_obj := audio_blue.o main_blue.o text_blue.o wram_blue.o .SUFFIXES: -.SUFFIXES: .asm .o .gbc .png .2bpp .1bpp .pic .SECONDEXPANSION: -# Suppress annoying intermediate file deletion messages. -.PRECIOUS: %.2bpp -.PHONY: all clean red blue compare +.PRECIOUS: +.SECONDARY: +.PHONY: all clean red blue compare tools roms := pokered.gbc pokeblue.gbc @@ -29,14 +22,26 @@ compare: red blue clean: rm -f $(roms) $(pokered_obj) $(pokeblue_obj) $(roms:.gbc=.sym) find . \( -iname '*.1bpp' -o -iname '*.2bpp' -o -iname '*.pic' \) -exec rm {} + + $(MAKE) clean -C tools/ + +tools: + $(MAKE) -C tools/ + + +# Build tools when building the rom. +# This has to happen before the rules are processed, since that's when scan_includes is run. +ifeq (,$(filter clean tools,$(MAKECMDGOALS))) +$(info $(shell $(MAKE) -C tools)) +endif + %.asm: ; -%_red.o: dep = $(shell $(includes) $(@D)/$*.asm) +%_red.o: dep = $(shell tools/scan_includes $(@D)/$*.asm) $(pokered_obj): %_red.o: %.asm $$(dep) rgbasm -D _RED -h -o $@ $*.asm -%_blue.o: dep = $(shell $(includes) $(@D)/$*.asm) +%_blue.o: dep = $(shell tools/scan_includes $(@D)/$*.asm) $(pokeblue_obj): %_blue.o: %.asm $$(dep) rgbasm -D _BLUE -h -o $@ $*.asm @@ -48,7 +53,26 @@ pokeblue_opt = -jsv -k 01 -l 0x33 -m 0x13 -p 0 -r 03 -t "POKEMON BLUE" rgbfix $($*_opt) $@ sort $*.sym -o $*.sym -%.png: ; -%.2bpp: %.png ; @$(2bpp) $< -%.1bpp: %.png ; @$(1bpp) $< -%.pic: %.2bpp ; @$(pic) $< +gfx/blue/intro_purin_1.2bpp: rgbgfx += -h +gfx/blue/intro_purin_2.2bpp: rgbgfx += -h +gfx/blue/intro_purin_3.2bpp: rgbgfx += -h +gfx/red/intro_nido_1.2bpp: rgbgfx += -h +gfx/red/intro_nido_2.2bpp: rgbgfx += -h +gfx/red/intro_nido_3.2bpp: rgbgfx += -h + +gfx/game_boy.2bpp: tools/gfx += --remove-duplicates +gfx/theend.2bpp: tools/gfx += --interleave --png=$< +gfx/tilesets/%.2bpp: tools/gfx += --trim-whitespace + +%.png: ; + +%.2bpp: %.png + rgbgfx $(rgbgfx) -o $@ $< + $(if $(tools/gfx),\ + tools/gfx $(tools/gfx) -o $@ $@) +%.1bpp: %.png + rgbgfx -d1 $(rgbgfx) -o $@ $< + $(if $(tools/gfx),\ + tools/gfx $(tools/gfx) -d1 -o $@ $@) +%.pic: %.2bpp + tools/pkmncompress $< $@ diff --git a/engine/HoF_room_pc.asm b/engine/HoF_room_pc.asm index fb196486..7e08631c 100755 --- a/engine/HoF_room_pc.asm +++ b/engine/HoF_room_pc.asm @@ -266,5 +266,5 @@ INCLUDE "data/credits_order.asm" INCLUDE "text/credits_text.asm" TheEndGfx: - INCBIN "gfx/theend.interleave.2bpp" + INCBIN "gfx/theend.2bpp" TheEndGfxEnd: diff --git a/engine/intro.asm b/engine/intro.asm index ed532681..422bcf7a 100755 --- a/engine/intro.asm +++ b/engine/intro.asm @@ -443,14 +443,14 @@ FightIntroBackMonEnd: FightIntroFrontMon: IF DEF(_RED) - INCBIN "gfx/red/intro_nido_1.6x6.2bpp" - INCBIN "gfx/red/intro_nido_2.6x6.2bpp" - INCBIN "gfx/red/intro_nido_3.6x6.2bpp" + INCBIN "gfx/red/intro_nido_1.2bpp" + INCBIN "gfx/red/intro_nido_2.2bpp" + INCBIN "gfx/red/intro_nido_3.2bpp" ENDC IF DEF(_BLUE) - INCBIN "gfx/blue/intro_purin_1.6x6.2bpp" - INCBIN "gfx/blue/intro_purin_2.6x6.2bpp" - INCBIN "gfx/blue/intro_purin_3.6x6.2bpp" + INCBIN "gfx/blue/intro_purin_1.2bpp" + INCBIN "gfx/blue/intro_purin_2.2bpp" + INCBIN "gfx/blue/intro_purin_3.2bpp" ENDC FightIntroFrontMonEnd: diff --git a/gfx/blue/intro_purin_1.6x6.png b/gfx/blue/intro_purin_1.png similarity index 100% rename from gfx/blue/intro_purin_1.6x6.png rename to gfx/blue/intro_purin_1.png diff --git a/gfx/blue/intro_purin_2.6x6.png b/gfx/blue/intro_purin_2.png similarity index 100% rename from gfx/blue/intro_purin_2.6x6.png rename to gfx/blue/intro_purin_2.png diff --git a/gfx/blue/intro_purin_3.6x6.png b/gfx/blue/intro_purin_3.png similarity index 100% rename from gfx/blue/intro_purin_3.6x6.png rename to gfx/blue/intro_purin_3.png diff --git a/gfx/game_boy.norepeat.png b/gfx/game_boy.png similarity index 100% rename from gfx/game_boy.norepeat.png rename to gfx/game_boy.png diff --git a/gfx/red/intro_nido_1.6x6.png b/gfx/red/intro_nido_1.png similarity index 100% rename from gfx/red/intro_nido_1.6x6.png rename to gfx/red/intro_nido_1.png diff --git a/gfx/red/intro_nido_2.6x6.png b/gfx/red/intro_nido_2.png similarity index 100% rename from gfx/red/intro_nido_2.6x6.png rename to gfx/red/intro_nido_2.png diff --git a/gfx/red/intro_nido_3.6x6.png b/gfx/red/intro_nido_3.png similarity index 100% rename from gfx/red/intro_nido_3.6x6.png rename to gfx/red/intro_nido_3.png diff --git a/gfx/theend.interleave.png b/gfx/theend.png similarity index 100% rename from gfx/theend.interleave.png rename to gfx/theend.png diff --git a/gfx/tilesets/cavern.t14.png b/gfx/tilesets/cavern.png similarity index 100% rename from gfx/tilesets/cavern.t14.png rename to gfx/tilesets/cavern.png diff --git a/gfx/tilesets/cemetery.t4.png b/gfx/tilesets/cemetery.png similarity index 100% rename from gfx/tilesets/cemetery.t4.png rename to gfx/tilesets/cemetery.png diff --git a/gfx/tilesets/club.t5.png b/gfx/tilesets/club.png similarity index 100% rename from gfx/tilesets/club.t5.png rename to gfx/tilesets/club.png diff --git a/gfx/tilesets/gate.t1.png b/gfx/tilesets/gate.png similarity index 100% rename from gfx/tilesets/gate.t1.png rename to gfx/tilesets/gate.png diff --git a/gfx/tilesets/house.t2.png b/gfx/tilesets/house.png similarity index 100% rename from gfx/tilesets/house.t2.png rename to gfx/tilesets/house.png diff --git a/gfx/tilesets/interior.t1.png b/gfx/tilesets/interior.png similarity index 100% rename from gfx/tilesets/interior.t1.png rename to gfx/tilesets/interior.png diff --git a/gfx/tilesets/lab.t4.png b/gfx/tilesets/lab.png similarity index 100% rename from gfx/tilesets/lab.t4.png rename to gfx/tilesets/lab.png diff --git a/gfx/tilesets/lobby.t2.png b/gfx/tilesets/lobby.png similarity index 100% rename from gfx/tilesets/lobby.t2.png rename to gfx/tilesets/lobby.png diff --git a/gfx/tilesets/mansion.t2.png b/gfx/tilesets/mansion.png similarity index 100% rename from gfx/tilesets/mansion.t2.png rename to gfx/tilesets/mansion.png diff --git a/gfx/tilesets/overworld.t2.png b/gfx/tilesets/overworld.png similarity index 100% rename from gfx/tilesets/overworld.t2.png rename to gfx/tilesets/overworld.png diff --git a/gfx/tilesets/plateau.t10.png b/gfx/tilesets/plateau.png similarity index 100% rename from gfx/tilesets/plateau.t10.png rename to gfx/tilesets/plateau.png diff --git a/gfx/tilesets/reds_house.t7.png b/gfx/tilesets/reds_house.png similarity index 100% rename from gfx/tilesets/reds_house.t7.png rename to gfx/tilesets/reds_house.png diff --git a/gfx/tilesets/ship.t6.png b/gfx/tilesets/ship.png similarity index 100% rename from gfx/tilesets/ship.t6.png rename to gfx/tilesets/ship.png diff --git a/gfx/tilesets/ship_port.t2.png b/gfx/tilesets/ship_port.png similarity index 100% rename from gfx/tilesets/ship_port.t2.png rename to gfx/tilesets/ship_port.png diff --git a/gfx/tilesets/underground.t7.png b/gfx/tilesets/underground.png similarity index 100% rename from gfx/tilesets/underground.t7.png rename to gfx/tilesets/underground.png diff --git a/main.asm b/main.asm index 041479d9..065700da 100755 --- a/main.asm +++ b/main.asm @@ -895,7 +895,7 @@ INCLUDE "engine/battle/trainer_ai.asm" INCLUDE "engine/battle/draw_hud_pokeball_gfx.asm" TradingAnimationGraphics: -INCBIN "gfx/game_boy.norepeat.2bpp" +INCBIN "gfx/game_boy.2bpp" INCBIN "gfx/link_cable.2bpp" TradingAnimationGraphicsEnd: @@ -1846,23 +1846,24 @@ INCLUDE "engine/hidden_object_functions18.asm" SECTION "bank19",ROMX,BANK[$19] -Overworld_GFX: INCBIN "gfx/tilesets/overworld.t2.2bpp" +Overworld_GFX: INCBIN "gfx/tilesets/overworld.2bpp" Overworld_Block: INCBIN "gfx/blocksets/overworld.bst" RedsHouse1_GFX: -RedsHouse2_GFX: INCBIN "gfx/tilesets/reds_house.t7.2bpp" +RedsHouse2_GFX: INCBIN "gfx/tilesets/reds_house.2bpp" + ds 16 RedsHouse1_Block: RedsHouse2_Block: INCBIN "gfx/blocksets/reds_house.bst" -House_GFX: INCBIN "gfx/tilesets/house.t2.2bpp" +House_GFX: INCBIN "gfx/tilesets/house.2bpp" House_Block: INCBIN "gfx/blocksets/house.bst" -Mansion_GFX: INCBIN "gfx/tilesets/mansion.t2.2bpp" +Mansion_GFX: INCBIN "gfx/tilesets/mansion.2bpp" Mansion_Block: INCBIN "gfx/blocksets/mansion.bst" -ShipPort_GFX: INCBIN "gfx/tilesets/ship_port.t2.2bpp" +ShipPort_GFX: INCBIN "gfx/tilesets/ship_port.2bpp" ShipPort_Block: INCBIN "gfx/blocksets/ship_port.bst" -Interior_GFX: INCBIN "gfx/tilesets/interior.t1.2bpp" +Interior_GFX: INCBIN "gfx/tilesets/interior.2bpp" Interior_Block: INCBIN "gfx/blocksets/interior.bst" -Plateau_GFX: INCBIN "gfx/tilesets/plateau.t10.2bpp" +Plateau_GFX: INCBIN "gfx/tilesets/plateau.2bpp" Plateau_Block: INCBIN "gfx/blocksets/plateau.bst" @@ -1891,7 +1892,7 @@ Pokecenter_Block: INCBIN "gfx/blocksets/pokecenter.bst" ForestGate_GFX: Museum_GFX: -Gate_GFX: INCBIN "gfx/tilesets/gate.t1.2bpp" +Gate_GFX: INCBIN "gfx/tilesets/gate.2bpp" ForestGate_Block: Museum_Block: Gate_Block: INCBIN "gfx/blocksets/gate.bst" @@ -1904,19 +1905,19 @@ Facility_Block: INCBIN "gfx/blocksets/facility.bst" SECTION "bank1B",ROMX,BANK[$1B] -Cemetery_GFX: INCBIN "gfx/tilesets/cemetery.t4.2bpp" +Cemetery_GFX: INCBIN "gfx/tilesets/cemetery.2bpp" Cemetery_Block: INCBIN "gfx/blocksets/cemetery.bst" -Cavern_GFX: INCBIN "gfx/tilesets/cavern.t14.2bpp" +Cavern_GFX: INCBIN "gfx/tilesets/cavern.2bpp" Cavern_Block: INCBIN "gfx/blocksets/cavern.bst" -Lobby_GFX: INCBIN "gfx/tilesets/lobby.t2.2bpp" +Lobby_GFX: INCBIN "gfx/tilesets/lobby.2bpp" Lobby_Block: INCBIN "gfx/blocksets/lobby.bst" -Ship_GFX: INCBIN "gfx/tilesets/ship.t6.2bpp" +Ship_GFX: INCBIN "gfx/tilesets/ship.2bpp" Ship_Block: INCBIN "gfx/blocksets/ship.bst" -Lab_GFX: INCBIN "gfx/tilesets/lab.t4.2bpp" +Lab_GFX: INCBIN "gfx/tilesets/lab.2bpp" Lab_Block: INCBIN "gfx/blocksets/lab.bst" -Club_GFX: INCBIN "gfx/tilesets/club.t5.2bpp" +Club_GFX: INCBIN "gfx/tilesets/club.2bpp" Club_Block: INCBIN "gfx/blocksets/club.bst" -Underground_GFX: INCBIN "gfx/tilesets/underground.t7.2bpp" +Underground_GFX: INCBIN "gfx/tilesets/underground.2bpp" Underground_Block: INCBIN "gfx/blocksets/underground.bst" diff --git a/tools/.gitignore b/tools/.gitignore new file mode 100644 index 00000000..967af106 --- /dev/null +++ b/tools/.gitignore @@ -0,0 +1,3 @@ +scan_includes +gfx +pkmncompress diff --git a/tools/Makefile b/tools/Makefile new file mode 100644 index 00000000..13bab1fb --- /dev/null +++ b/tools/Makefile @@ -0,0 +1,16 @@ +.PHONY: all clean + +CC := gcc +CFLAGS := -O3 -std=c99 -Wall -Wextra + +tools := scan_includes gfx pkmncompress + +all: $(tools) + @: + +clean: + rm -f $(tools) + +gfx: common.h +%: %.c + $(CC) $(CFLAGS) -o $@ $< diff --git a/tools/common.h b/tools/common.h new file mode 100644 index 00000000..4da0b2ef --- /dev/null +++ b/tools/common.h @@ -0,0 +1,40 @@ +#ifndef GUARD_COMMON_H +#define GUARD_COMMON_H + +int __getopt_long_i__; +#define getopt_long(c, v, s, l) getopt_long(c, v, s, l, &__getopt_long_i__) + +FILE *fopen_verbose(char *filename, char *mode) { + FILE *f = fopen(filename, mode); + if (!f) { + fprintf(stderr, "Could not open file: \"%s\"\n", filename); + } + return f; +} + +uint8_t *read_u8(char *filename, int *size) { + FILE *f = fopen_verbose(filename, "rb"); + if (!f) { + exit(1); + } + fseek(f, 0, SEEK_END); + *size = ftell(f); + rewind(f); + uint8_t *data = malloc(*size); + if (*size != (int)fread(data, 1, *size, f)) { + fprintf(stderr, "Could not read file: \"%s\"\n", filename); + exit(1); + } + fclose(f); + return data; +} + +void write_u8(char *filename, uint8_t *data, int size) { + FILE *f = fopen_verbose(filename, "wb"); + if (f) { + fwrite(data, 1, size, f); + fclose(f); + } +} + +#endif // GUARD_COMMON_H diff --git a/tools/gfx.c b/tools/gfx.c new file mode 100644 index 00000000..8c4066ab --- /dev/null +++ b/tools/gfx.c @@ -0,0 +1,296 @@ +#include +#include +#include +#include +#include +#include + +#include "common.h" + +static void usage(void) { + fprintf(stderr, "Usage: gfx [--trim-whitespace] [--remove-whitespace] [--interleave] [--remove-duplicates [--keep-whitespace]] [--remove-xflip] [--remove-yflip] [--png filename] [-d depth] [-h] [-o outfile] infile\n"); +} + +static void error(char *message) { + fputs(message, stderr); + fputs("\n", stderr); +} + +struct Options { + int trim_whitespace; + int remove_whitespace; + int help; + char *outfile; + int depth; + int interleave; + int remove_duplicates; + int keep_whitespace; + int remove_xflip; + int remove_yflip; + char *png_file; +}; + +struct Options Options = { + .depth = 2, +}; + +void get_args(int argc, char *argv[]) { + struct option long_options[] = { + {"remove-whitespace", no_argument, &Options.remove_whitespace, 1}, + {"trim-whitespace", no_argument, &Options.trim_whitespace, 1}, + {"interleave", no_argument, &Options.interleave, 1}, + {"remove-duplicates", no_argument, &Options.remove_duplicates, 1}, + {"keep-whitespace", no_argument, &Options.keep_whitespace, 1}, + {"remove-xflip", no_argument, &Options.remove_xflip, 1}, + {"remove-yflip", no_argument, &Options.remove_yflip, 1}, + {"png", required_argument, 0, 'p'}, + {"depth", required_argument, 0, 'd'}, + {"help", no_argument, 0, 'h'}, + {0} + }; + for (int opt = 0; opt != -1;) { + switch (opt = getopt_long(argc, argv, "ho:d:p:", long_options)) { + case 'h': + Options.help = true; + break; + case 'o': + Options.outfile = optarg; + break; + case 'd': + Options.depth = strtoul(optarg, NULL, 0); + break; + case 'p': + Options.png_file = optarg; + break; + case 0: + case -1: + break; + default: + usage(); + exit(1); + break; + } + } +} + +struct Graphic { + int size; + uint8_t *data; +}; + +bool is_whitespace(uint8_t *tile, int tile_size) { + uint8_t WHITESPACE = 0; + for (int i = 0; i < tile_size; i++) { + if (tile[i] != WHITESPACE) { + return false; + } + } + return true; +} + +void trim_whitespace(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + for (int i = graphic->size - tile_size; i > 0; i -= tile_size) { + if (is_whitespace(&graphic->data[i], tile_size)) { + graphic->size = i; + } else { + break; + } + } +} + +void remove_whitespace(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int i = 0; + for (int j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (is_whitespace(&graphic->data[j], tile_size)) { + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + } + graphic->size = i; +} + +bool tile_exists(uint8_t *tile, uint8_t *tiles, int tile_size, int num_tiles) { + for (int i = 0; i < num_tiles; i++) { + bool match = true; + for (int j = 0; j < tile_size; j++) { + if (tile[j] != tiles[i * tile_size + j]) { + match = false; + } + } + if (match) { + return true; + } + } + return false; +} + +void remove_duplicates(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int num_tiles = 0; + for (int i = 0, j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (tile_exists(&graphic->data[j], graphic->data, tile_size, num_tiles)) { + if (Options.keep_whitespace && is_whitespace(&graphic->data[j], tile_size)) { + break; + } + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + num_tiles++; + } + graphic->size = num_tiles * tile_size; +} + +bool flip_exists(uint8_t *tile, uint8_t *tiles, int tile_size, int num_tiles, bool xflip, bool yflip) { + uint8_t *flip = calloc(tile_size, 1); + int half_size = tile_size / 2; + for (int i = 0; i < tile_size; i++) { + int byte = i; + if (yflip) { + byte = tile_size - 1 - (i ^ 1); + if (Options.interleave && i < half_size) { + byte = half_size - 1 - (i ^ 1); + } + } + if (xflip) { + for (int bit = 0; bit < 8; bit++) { + flip[byte] |= ((tile[i] >> bit) & 1) << (7 - bit); + } + } else { + flip[byte] = tile[i]; + } + } + if (tile_exists(flip, tiles, tile_size, num_tiles)) { + return true; + } + return false; +} + +void remove_flip(struct Graphic *graphic, bool xflip, bool yflip) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int num_tiles = 0; + for (int i = 0, j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (flip_exists(&graphic->data[j], graphic->data, tile_size, num_tiles, xflip, yflip)) { + if (Options.keep_whitespace && is_whitespace(&graphic->data[j], tile_size)) { + break; + } + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + num_tiles++; + } + graphic->size = num_tiles * tile_size; +} + +void interleave(struct Graphic *graphic, int width) { + int tile_size = Options.depth * 8; + int width_tiles = width / 8; + int num_tiles = graphic->size / tile_size; + uint8_t *interleaved = malloc(graphic->size); + for (int i = 0; i < num_tiles; i++) { + int tile = i * 2; + int row = i / width_tiles; + tile -= width_tiles * row; + if (row % 2) { + tile -= width_tiles; + tile += 1; + } + memcpy(&interleaved[tile * tile_size], &graphic->data[i * tile_size], tile_size); + } + graphic->size = num_tiles * tile_size; + memcpy(graphic->data, interleaved, graphic->size); + free(interleaved); +} + +int png_get_width(char *filename) { + FILE *f = fopen_verbose(filename, "rb"); + if (!f) { + exit(1); + } + + const int OFFSET_WIDTH = 16; + uint8_t bytes[4]; + fseek(f, OFFSET_WIDTH, SEEK_SET); + size_t size = 4; + size_t result = fread(bytes, 1, size, f); + fclose(f); + if (result != size) { + fprintf(stderr, "Could not read file at offset 0x%x: \"%s\"\n", OFFSET_WIDTH, filename); + exit(1); + } + + int width = 0; + for (int i = 0; i < 4; i++) { + width |= bytes[i] << (8 * (3 - i)); + } + return width; +} + + +int main(int argc, char *argv[]) { + get_args(argc, argv); + argc -= optind; + argv += optind; + if (Options.help) { + usage(); + return 0; + } + if (argc < 1) { + usage(); + exit(1); + } + char *infile = argv[0]; + struct Graphic graphic; + graphic.data = read_u8(infile, &graphic.size); + if (Options.trim_whitespace) { + trim_whitespace(&graphic); + } + if (Options.interleave) { + if (!Options.png_file) { + error("interleave: need --png to infer dimensions"); + usage(); + exit(1); + } + int width = png_get_width(Options.png_file); + interleave(&graphic, width); + } + if (Options.remove_duplicates) { + remove_duplicates(&graphic); + } + if (Options.remove_xflip) { + remove_flip(&graphic, true, false); + } + if (Options.remove_yflip) { + remove_flip(&graphic, false, true); + } + if (Options.remove_xflip && Options.remove_yflip) { + remove_flip(&graphic, true, true); + } + if (Options.remove_whitespace) { + remove_whitespace(&graphic); + } + if (Options.outfile) { + write_u8(Options.outfile, graphic.data, graphic.size); + } + free(graphic.data); + return 0; +} diff --git a/tools/pkmncompress.c b/tools/pkmncompress.c new file mode 100644 index 00000000..db707653 --- /dev/null +++ b/tools/pkmncompress.c @@ -0,0 +1,451 @@ +/* + * Copyright © 2013 stag019 + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include + +typedef uint8_t u8; + +u8 *compressed = NULL; +int xrows = 0; +int xwidth = 0; +int curbit = 0; +int curbyte = 0; + +void writebit(int bit) +{ + if (++curbit == 8) + { + curbyte++; + curbit = 0; + } + compressed[curbyte] |= bit << (7 - curbit); +} + +void method_1(u8 *RAM) +{ + int i; + int j; + int nibble_1; + int nibble_2 = 0; + int code_1; + int code_2; + int table; + static int method_1[2][0x10] = { + {0x0, 0x1, 0x3, 0x2, 0x6, 0x7, 0x5, 0x4, 0xC, 0xD, 0xF, 0xE, 0xA, 0xB, 0x9, 0x8}, + {0x8, 0x9, 0xB, 0xA, 0xE, 0xF, 0xD, 0xC, 0x4, 0x5, 0x7, 0x6, 0x2, 0x3, 0x1, 0x0} + }; + + for (i = 0; i < xrows * xwidth * 8; i++) + { + j = i / xrows; + j += i % xrows * xwidth * 8; + if (!(i % xrows)) + { + nibble_2 = 0; + } + nibble_1 = (RAM[j] >> 4) & 0x0F; + table = 0; + if (nibble_2 & 1) + { + table = 1; + } + code_1 = method_1[table][nibble_1]; + nibble_2 = RAM[j] & 0x0F; + table = 0; + if (nibble_1 & 1) + { + table = 1; + } + code_2 = method_1[table][nibble_2]; + RAM[j] = (code_1 << 4) | code_2; + } +} + +// "Get the previous power of 2. Deriving the bitcount from that seems to be faster on average than using the lookup table." +void RLE(int nums) +{ + int v; + int j; + int bitcount; + int number; + + bitcount = -1; + v = ++nums; + v++; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v -= v >> 1; + v--; + + number = nums - v; + while(v) { + v >>= 1; + bitcount++; + } + for(j = 0; j < bitcount; j++) { + writebit(1); + } + writebit(0); + for(j = bitcount; j >= 0; j--) { + writebit((number >> j) & 1); + } +} + +void RLE_old(int nums) +{ + int search; + int i; + int j; + int bitcount; + int number; + static int RLE[0x10] = {0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF}; + + bitcount = -1; + search = ++nums; + while (search > 0) + { + for (i = 0; i < 0xF; i++) + { + if (RLE[i] == search) + { + bitcount = i; + break; + } + } + if (bitcount != -1) + { + break; + } + search--; + } + number = nums - RLE[bitcount]; + for (j = 0; j < bitcount; j++) + { + writebit(1); + } + writebit(0); + for (j = bitcount; j >= 0; j--) + { + writebit((number >> j) & 1); + } +} + +void data_packet(u8 *bitgroups, int bgi) +{ + int i; + for (i = 0; i < bgi; i++) + { + writebit((bitgroups[i] >> 1) & 1); + writebit(bitgroups[i] & 1); + } +} + +int interpret_compress(u8 *RAM_1, u8 *RAM_2, int interpretation, int switchram) +{ + u8 *_1_RAM; + u8 *_2_RAM; + int i; + int ram; + int type; + int nums; + u8 *bitgroups; + int x; + int y; + int byte; + int bit; + int bitgroup; + int bgi = 0; + + int ram_size = xrows * xwidth * 8; + _1_RAM = (u8 *)calloc(ram_size, 1); + _2_RAM = (u8 *)calloc(ram_size, 1); + if (switchram) + { + memcpy(_1_RAM, RAM_2, ram_size); + memcpy(_2_RAM, RAM_1, ram_size); + } + else + { + memcpy(_1_RAM, RAM_1, ram_size); + memcpy(_2_RAM, RAM_2, ram_size); + } + + switch(interpretation) + { + case 1: + method_1(_1_RAM); + method_1(_2_RAM); + break; + case 2: + case 3: + for (i = 0; i < xrows * xwidth * 8; i++) + { + _2_RAM[i] ^= _1_RAM[i]; + } + method_1(_1_RAM); + break; + } + if (interpretation == 3) + { + method_1(_2_RAM); + } + + curbit = 7; + curbyte = 0; + compressed = (u8 *)calloc(0x310, 1); + compressed[0] = (xrows << 4) | xwidth; + writebit(switchram); + + for (ram = 0; ram < 2; ram++) + { + type = 0; + nums = 0; + bitgroups = (u8 *)calloc(0x1000, 1); + + for (x = 0; x < xwidth; x++) + { + for (bit = 0; bit < 8; bit += 2) + { + byte = x * xrows * 8; + for (y=0; y < xrows * 8; y++) + { + if (ram) + { + bitgroup = (_2_RAM[byte] >> (6 - bit)) & 3; + } + else + { + bitgroup = (_1_RAM[byte] >> (6 - bit)) & 3; + } + if (!bitgroup) + { + if (!type) + { + writebit(0); + } + else if (type == 1) + { + nums++; + } + else + { + data_packet(bitgroups, bgi); + writebit(0); + writebit(0); + } + type = 1; + free(bitgroups); + bitgroups = (u8 *)calloc(0x1000, 1); + bgi = 0; + } + else + { + if (!type) + { + writebit(1); + } + else if (type == 1) + { + RLE(nums); + } + type = -1; + bitgroups[bgi++] = bitgroup; + nums = 0; + } + byte++; + } + } + } + if (type == 1) + { + RLE(nums); + } + else + { + data_packet(bitgroups, bgi); + } + if (!ram) + { + if (interpretation < 2) + { + writebit(0); + } + else + { + writebit(1); + writebit(interpretation - 2); + } + } + } + free(bitgroups); + free(_1_RAM); + free(_2_RAM); + return (curbyte + 1) * 8 + curbit; +} + +int compress(u8 *data, int width, int height) +{ + u8 *RAM_1; + u8 *RAM_2; + int i; + int mode; + int order; + int newsize; + int compressedsize; + int size = -1; + u8 *current = NULL; + int ram_size; + + xrows = height; + xwidth = width; + + ram_size = xrows * xwidth * 8; + + RAM_1 = (u8 *)calloc(ram_size, 1); + RAM_2 = (u8 *)calloc(ram_size, 1); + + for (i = 0; i < xrows * xwidth * 8; i++) + { + RAM_1[i] = data[(i << 1)]; + RAM_2[i] = data[(i << 1) | 1]; + } + + for (mode = 1; mode < 4; mode++) + { + for (order = 0; order < 2; order++) + { + if (!(mode == 1 && order == 0)) + { + newsize = interpret_compress(RAM_1, RAM_2, mode, order); + if (size == -1 || newsize < size) + { + if (current != NULL) + { + free(current); + } + current = (u8 *)calloc(0x310, 1); + memcpy(current, compressed, newsize / 8); + free(compressed); + size = newsize; + } + } + } + } + compressed = (u8 *)calloc(0x310, 1); + compressedsize = size / 8; + memcpy(compressed, current, compressedsize); + free(current); + + free(RAM_1); + free(RAM_2); + + return compressedsize; +} + +uint8_t *transpose_tiles(uint8_t *data, int width, int height) +{ + int i; + int j; + int tile_size = 0x10; + + int size = width * height * tile_size; + u8 *transposed = calloc(size, 1); + for (i = 0; i < size; i++) + { + j = (i / 0x10) * width * 0x10; + j = (j % size) + 0x10 * (j / size) + (i % 0x10); + transposed[j] = data[i]; + } + + free(data); + + return transposed; +} + +int main(int argc, char *argv[]) +{ + int width = 0; + int height = 0; + int transpose = 1; + + if (argc != 3) + { + fputs("Usage: pkmncompress infile.2bpp outfile.pic\n", stderr); + return EXIT_FAILURE; + } + + char *infile = argv[1]; + char *outfile = argv[2]; + + FILE *f = fopen(infile, "rb"); + if (!f) { + fprintf(stderr, "failed to open for reading: '%s'\n", infile); + return EXIT_FAILURE; + } + fseek(f, 0, SEEK_END); + int filesize = ftell(f); + + for (int i = 0; i < 32; i++) { + width = i; + height = i; + if (width * height * 16 >= filesize) { + break; + } + } + if (width * height * 16 < filesize) { + fprintf(stderr, "file too big: '%s' (%x)\n", infile, filesize); + return EXIT_FAILURE; + } + if (width * height * 16 > filesize) { + fprintf(stderr, "wrong filesize for '%s' (%x). must be a square image of 16-byte tiles\n", infile, filesize); + return EXIT_FAILURE; + } + + u8 *data = (u8 *)calloc(filesize, 1); + fseek(f, 0, SEEK_SET); + int size = fread(data, 1, filesize, f); + fclose(f); + if (size != filesize) { + fprintf(stderr, "failed to read: '%s'\n", infile); + return EXIT_FAILURE; + } + + if (transpose) { + data = transpose_tiles(data, width, height); + } + + int compressed_size = compress(data, width, height); + + free(data); + + f = fopen(outfile, "wb"); + if (!f) { + fprintf(stderr, "failed to open for writing: '%s'\n", outfile); + return EXIT_FAILURE; + } + fwrite(compressed, 1, compressed_size, f); + fclose(f); + + free(compressed); + + return EXIT_SUCCESS; +} diff --git a/tools/scan_includes.c b/tools/scan_includes.c new file mode 100644 index 00000000..63af3bcf --- /dev/null +++ b/tools/scan_includes.c @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include + +void usage(void) { + printf("Usage: scan_includes [-h] [-s] filename\n" + "-h, --help\n" + " Print usage and exit\n" + "-s, --strict\n" + " Fail if a file cannot be read\n"); +} + +struct Options { + bool help; + bool strict; +}; + +struct Options Options = {0}; + +void scan_file(char* filename) { + FILE *f = fopen(filename, "rb"); + if (!f) { + if (Options.strict) { + fprintf(stderr, "Could not open file: '%s'\n", filename); + exit(1); + } else { + return; + } + } + + fseek(f, 0, SEEK_END); + long size = ftell(f); + rewind(f); + + char *buffer = malloc(size + 1); + char *orig = buffer; + size = fread(buffer, 1, size, f); + buffer[size] = '\0'; + fclose(f); + + for (; buffer && (buffer - orig < size); buffer++) { + bool is_include = false; + bool is_incbin = false; + switch (*buffer) { + case ';': + buffer = strchr(buffer, '\n'); + if (!buffer) { + fprintf(stderr, "%s: no newline at end of file\n", filename); + break; + } + break; + + case '"': + buffer++; + buffer = strchr(buffer, '"'); + if (!buffer) { + fprintf(stderr, "%s: unterminated string\n", filename); + break; + } + buffer++; + break; + + case 'i': + case 'I': + if ((strncmp(buffer, "INCBIN", 6) == 0) || (strncmp(buffer, "incbin", 6) == 0)) { + is_incbin = true; + } else if ((strncmp(buffer, "INCLUDE", 7) == 0) || (strncmp(buffer, "include", 7) == 0)) { + is_include = true; + } + if (is_incbin || is_include) { + buffer = strchr(buffer, '"'); + if (!buffer) { + break; + } + buffer++; + int length = strcspn(buffer, "\""); + char *include = malloc(length + 1); + strncpy(include, buffer, length); + include[length] = '\0'; + printf("%s ", include); + if (is_include) { + scan_file(include); + } + free(include); + buffer = strchr(buffer, '"'); + } + break; + + } + if (!buffer) { + break; + } + + } + + free(orig); +} + +int main(int argc, char* argv[]) { + int i = 0; + struct option long_options[] = { + {"strict", no_argument, 0, 's'}, + {"help", no_argument, 0, 'h'}, + {0} + }; + int opt = -1; + while ((opt = getopt_long(argc, argv, "sh", long_options, &i)) != -1) { + switch (opt) { + case 's': + Options.strict = true; + break; + case 'h': + Options.help = true; + break; + default: + usage(); + exit(1); + break; + } + } + argc -= optind; + argv += optind; + if (Options.help) { + usage(); + return 0; + } + if (argc < 1) { + usage(); + exit(1); + } + scan_file(argv[0]); + return 0; +}