cappy4king
/
marseymoji
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
marseymoji/Makefile

231 lines
7.1 KiB
Makefile
Raw Normal View History

Add the sources of the color emoji font.
2014-07-09 07:20:14 +00:00
# Copyright 2014 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
Rename variables in Makefile.
2014-07-10 04:04:19 +00:00
EMOJI = NotoColorEmoji
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
font: $(EMOJI).ttf
CFLAGS = -std=c99 -Wall -Wextra `pkg-config --cflags --libs cairo`
Update waveflag.c to upstream version. Also updates LDFLAGS to match upstream.
2016-10-07 21:17:09 +00:00
LDFLAGS = -lm `pkg-config --libs cairo`
Change Makefile to be smarter about dependencies. This reverts some changes in commit b257b6647d that were causing build issues. Those changes quoted the path to pngquant in order to deal with spaces in the path, but as a side effect that prevented build-dependency analysis (gnu 3.81 on ubuntu) from recognizing that the .png files didn't need to be built, and so rebuilt them every time, which takes several minutes. Apparently make doesn't like quotes-- strings passed to the shell are fine, but things make itself processes (like names of targets) are treated literally. Since the path to pngquant is (now, anyway) a local subpath of the current directory that has no spaces, it should be ok to use the subpath and not bother to quote. Another change replaces two dependencies on flag-symlinks with a dependency on PNG128_FLAGS, for the same reason: after flag-symlinks executed it was not recognized as being up to date and so the rules with these dependencies always executed.
2015-10-15 00:18:29 +00:00
PNGQUANTDIR := third_party/pngquant
Pass Noto Color Emoji bitmaps through pngquant.
2014-09-18 02:31:16 +00:00
PNGQUANT := $(PNGQUANTDIR)/pngquant
Use quality param with optipng. When images are not processed due to not being able to meet the minimum quality setting, error 99 is returned, so catch this too so we still copy the file. Might still want to tweak these settings.
2017-04-12 16:00:01 +00:00
PNGQUANTFLAGS = --speed 1 --skip-if-larger --quality 85-95 --force
Fix resize of grayscale images. When imagemagick 6.7.7-10 is processing the '-extent' operator and discovers an image is grayscale, it turns the 32-bit truecolor sRGB image into a grayscale image, but does so incorrectly-- the gray levels and alpha are wrong. Get around this by using composition to copy the source image over a slightly larger transparent image.
2017-04-12 15:53:18 +00:00
IMOPS = -size 136x128 canvas:none -compose copy -gravity center
Pass Noto Color Emoji bitmaps through pngquant.
2014-09-18 02:31:16 +00:00
Update NotoColorEmoji template so that it passes lint, bump version. - fix ascent/descent in hhea and os/2 to match noto UI expectations, zero linegap, clear useTypoMetrics bit, set weight to regular (400). - add missing entries to name table, update revision - map U+0000 to null glyph (not .notdef) In addition, this tweaks the Makefile in some small ways: - quiet zopflipng output somewhat (listen to your cpu fan to know that something's happening) :-) - make flag-symlinks target an order-only dependency (it was triggering quantize+compress even when images hadn't changed) - add comment about how to bypass make bug if multithread hangs
2015-12-01 01:49:52 +00:00
# zopflipng is better (about 5-10%) but much slower. it will be used if
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
# present. pass ZOPFLIPNG= as an arg to make to use optipng instead.
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
ZOPFLIPNG = zopflipng
OPTIPNG = optipng
EMOJI_BUILDER = third_party/color_emoji/emoji_builder.py
Rewrite add_glyphs, use alias table. This is a rewrite of add_glyphs in third_party/color_emoji. The primary motivation was to move special aliasing rules out of that code and use an external aliases file instead. This new version is a bit more thorough about aliasing, and hopefully a little easier to read. The new add_glyphs takes its parameters using keywords, so the invocation in the Makefile changed (as well as the path to the tool). emoji_aliases.txt was extended to add the flag aliases that were formerly defined in the old add_glyphs code. add_aliases was modified so the name of the alias file could be passed in as a parameter to the main utility function that reads the alias mapping from the file. The new code expects all glyphs used by the template GSUB tables to be named in the GlyphOrder table, but doesn't require the cmap and hmtx table to be fleshed out. The new code fleshes these out when it processes the sequences to add. As a result the cmap and hmtx tables in the template were truncated. The new code also sorts the GlyphOrder table when it extends/rebuilds it.
2017-02-18 02:59:05 +00:00
ADD_GLYPHS = add_glyphs.py
ADD_GLYPHS_FLAGS = -a emoji_aliases.txt
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
PUA_ADDER = map_pua_emoji.py
VS_ADDER = add_vs_cmap.py # from nototools
fix emoji source path
2015-11-14 01:57:17 +00:00
EMOJI_SRC_DIR := png/128
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
FLAGS_SRC_DIR := third_party/region-flags/png
BUILD_DIR := build
EMOJI_DIR := $(BUILD_DIR)/emoji
FLAGS_DIR := $(BUILD_DIR)/flags
RESIZED_FLAGS_DIR := $(BUILD_DIR)/resized_flags
RENAMED_FLAGS_DIR := $(BUILD_DIR)/renamed_flags
QUANTIZED_DIR := $(BUILD_DIR)/quantized_pngs
COMPRESSED_DIR := $(BUILD_DIR)/compressed_pngs
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
Add 'unknown flag' glyph. This uses PUA character U+FE82B for the unknown flag during processing. Currently I don't yet remove this from the cmap when we're done.
2016-03-13 21:56:02 +00:00
# Unknown flag is PUA fe82b
Add variable to color emoji Makefile for ten old flags only.
2014-08-14 19:02:14 +00:00
LIMITED_FLAGS = CN DE ES FR GB IT JP KR RU US
Improve flag support. This adds some additional flags to the default set. In addition, it contains code that creates ligatures for some flag sequences to others, for a few cases where we want different regions to share the same flag. Finally, it adds default ligatures so that pairs of regional indicator characters for which there's no predefined glyph get a 'missing flag' glyph. This avoids cases where sequences of regional indicator sequences accidentally match at odd locations because of a previous mismatch. There is no actual 'missing flag' glyph yet. The code uses an existing emoji as a placeholder.
2016-03-12 03:02:15 +00:00
SELECTED_FLAGS = AC AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ \
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
BA BB BD BE BF BG BH BI BJ BM BN BO BR BS BT BW BY BZ \
CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ \
DE DJ DK DM DO DZ \
EC EE EG ER ES ET EU \
FI FJ FM FO FR \
GA GB GD GE GG GH GI GL GM GN GQ GR GT GU GW GY \
HK HN HR HT HU \
Improve flag support. This adds some additional flags to the default set. In addition, it contains code that creates ligatures for some flag sequences to others, for a few cases where we want different regions to share the same flag. Finally, it adds default ligatures so that pairs of regional indicator characters for which there's no predefined glyph get a 'missing flag' glyph. This avoids cases where sequences of regional indicator sequences accidentally match at odd locations because of a previous mismatch. There is no actual 'missing flag' glyph yet. The code uses an existing emoji as a placeholder.
2016-03-12 03:02:15 +00:00
IC ID IE IL IM IN IO IQ IR IS IT \
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
JE JM JO JP \
KE KG KH KI KM KN KP KR KW KY KZ \
LA LB LC LI LK LR LS LT LU LV LY \
MA MC MD ME MG MH MK ML MM MN MO MP MR MS MT MU MV MW MX MY MZ \
NA NE NF NG NI NL NO NP NR NU NZ \
OM \
PA PE PF PG PH PK PL PN PR PS PT PW PY \
QA \
RO RS RU RW \
Improve flag support. This adds some additional flags to the default set. In addition, it contains code that creates ligatures for some flag sequences to others, for a few cases where we want different regions to share the same flag. Finally, it adds default ligatures so that pairs of regional indicator characters for which there's no predefined glyph get a 'missing flag' glyph. This avoids cases where sequences of regional indicator sequences accidentally match at odd locations because of a previous mismatch. There is no actual 'missing flag' glyph yet. The code uses an existing emoji as a placeholder.
2016-03-12 03:02:15 +00:00
SA SB SC SD SE SG SH SI SK SL SM SN SO SR SS ST SV SX SY SZ \
TA TC TD TG TH TJ TK TL TM TN TO TR TT TV TW TZ \
Fix location of new flag resources, and also update Makefile.
2017-01-24 22:27:29 +00:00
UA UG UN US UY UZ \
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
VA VC VE VG VI VN VU \
WS \
YE \
Support subregion flags when building the emoji font. - update Makefile to include approved GB subregion flags by default - update flag_glyph_name to generate sequence names for these - fix bug where the glyphorder table wasn't getting updated with components, which was causing ttx to fail when compiling the ttx to ttf in a later phase.
2017-01-26 00:57:37 +00:00
ZA ZM ZW \
GB-ENG GB-SCT GB-WLS
small fixes
2015-11-14 02:15:09 +00:00
ALL_FLAGS = $(basename $(notdir $(wildcard $(FLAGS_SRC_DIR)/*.png)))
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
FLAGS = $(SELECTED_FLAGS)
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
FLAG_NAMES = $(FLAGS:%=%.png)
FLAG_FILES = $(addprefix $(FLAGS_DIR)/, $(FLAG_NAMES))
RESIZED_FLAG_FILES = $(addprefix $(RESIZED_FLAGS_DIR)/, $(FLAG_NAMES))
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
FLAG_GLYPH_NAMES = $(shell ./flag_glyph_name.py $(FLAGS))
RENAMED_FLAG_NAMES = $(FLAG_GLYPH_NAMES:%=emoji_%.png)
RENAMED_FLAG_FILES = $(addprefix $(RENAMED_FLAGS_DIR)/, $(RENAMED_FLAG_NAMES))
EMOJI_NAMES = $(notdir $(wildcard $(EMOJI_SRC_DIR)/emoji_u*.png))
EMOJI_FILES= $(addprefix $(EMOJI_DIR)/,$(EMOJI_NAMES)))
ALL_NAMES = $(EMOJI_NAMES) $(RENAMED_FLAG_NAMES)
ALL_QUANTIZED_FILES = $(addprefix $(QUANTIZED_DIR)/, $(ALL_NAMES))
ALL_COMPRESSED_FILES = $(addprefix $(COMPRESSED_DIR)/, $(ALL_NAMES))
# tool checks
ifeq (,$(shell which $(ZOPFLIPNG)))
ifeq (,$(wildcard $(ZOPFLIPNG)))
MISSING_ZOPFLI = fail
endif
endif
ifeq (,$(shell which $(OPTIPNG)))
ifeq (,$(wildcard $(OPTIPNG)))
MISSING_OPTIPNG = fail
endif
endif
Add the sources of the color emoji font.
2014-07-09 07:20:14 +00:00
Reintroduce check for missing binary, using a different method. Another way to do this is to create a target, but when I tried that it reintroduced the dependency analysis problem-- rules with this dependency always triggered. Of course I might have missed something subtle. Both the target approach and this approach come from http://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile) This always runs, but unless you're just running clean you'd always want to perform this check, so I think that's ok.
2015-10-15 00:43:18 +00:00
ifeq (, $(shell which $(VS_ADDER)))
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
MISSING_ADDER = fail
Reintroduce check for missing binary, using a different method. Another way to do this is to create a target, but when I tried that it reintroduced the dependency analysis problem-- rules with this dependency always triggered. Of course I might have missed something subtle. Both the target approach and this approach come from http://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile) This always runs, but unless you're just running clean you'd always want to perform this check, so I think that's ok.
2015-10-15 00:43:18 +00:00
endif
Add the sources of the color emoji font.
2014-07-09 07:20:14 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
emoji: $(EMOJI_FILES)
flags: $(FLAG_FILES)
resized_flags: $(RESIZED_FLAG_FILES)
updates to support tr51 emoji sequences
2015-11-05 19:15:15 +00:00
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
renamed_flags: $(RENAMED_FLAG_FILES)
quantized: $(ALL_QUANTIZED_FILES)
compressed: $(ALL_COMPRESSED_FILES)
check_compress_tool:
ifdef MISSING_ZOPFLI
ifdef MISSING_OPTIPNG
$(error "neither $(ZOPFLIPNG) nor $(OPTIPNG) is available")
else
@echo "using $(OPTIPNG)"
endif
else
@echo "using $(ZOPFLIPNG)"
endif
check_vs_adder:
ifdef MISSING_ADDER
$(error "$(VS_ADDER) not in path, run setup.py in nototools")
endif
$(EMOJI_DIR) $(FLAGS_DIR) $(RESIZED_FLAGS_DIR) $(RENAMED_FLAGS_DIR) $(QUANTIZED_DIR) $(COMPRESSED_DIR):
mkdir -p "$@"
$(PNGQUANT):
$(MAKE) -C $(PNGQUANTDIR)
waveflag: waveflag.c
$(CC) $< -o $@ $(CFLAGS) $(LDFLAGS)
Fix resize of grayscale images. When imagemagick 6.7.7-10 is processing the '-extent' operator and discovers an image is grayscale, it turns the 32-bit truecolor sRGB image into a grayscale image, but does so incorrectly-- the gray levels and alpha are wrong. Get around this by using composition to copy the source image over a slightly larger transparent image.
2017-04-12 15:53:18 +00:00
# imagemagick's -extent operator munges the grayscale images in such a fashion
# that while it can display them correctly using libpng12, chrome and gimp using
# both libpng12 and libpng16 display the wrong gray levels.
#
# @convert "$<" -gravity center -background none -extent 136x128 "$@"
#
# We can get around the conversion to a gray colorspace in the version of
# imagemagick packaged with ubuntu trusty (6.7.7-10) by using -composite.
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(EMOJI_DIR)/%.png: $(EMOJI_SRC_DIR)/%.png | $(EMOJI_DIR)
Fix resize of grayscale images. When imagemagick 6.7.7-10 is processing the '-extent' operator and discovers an image is grayscale, it turns the 32-bit truecolor sRGB image into a grayscale image, but does so incorrectly-- the gray levels and alpha are wrong. Get around this by using composition to copy the source image over a slightly larger transparent image.
2017-04-12 15:53:18 +00:00
@convert $(IMOPS) "$<" -composite "PNG32:$@"
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(FLAGS_DIR)/%.png: $(FLAGS_SRC_DIR)/%.png ./waveflag $(PNGQUANT) | $(FLAGS_DIR)
Update for new waveflag semantics. Previously our copy of waveflag took just an input and output filename. Upstream takes a prefix and one or more input filenames, and concatenates the prefix to the input filename as the output. The makefile is changed to pass a prefix and the input filename, instead of the input filename and the output filename as it formerly did. Unfortunately for us, our inputs have a directory prefix since they're not in the current directory, and we don't want this prefix in the output file path. So we tweak our copy of waveflag.c to call basename on the input file path before we append it to the prefix. We also make the tool a little less noisy by putting more printfs under the debug flag.
2016-10-07 21:22:30 +00:00
@./waveflag $(FLAGS_DIR)/ "$<"
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(RESIZED_FLAGS_DIR)/%.png: $(FLAGS_DIR)/%.png | $(RESIZED_FLAGS_DIR)
Fix resize of grayscale images. When imagemagick 6.7.7-10 is processing the '-extent' operator and discovers an image is grayscale, it turns the 32-bit truecolor sRGB image into a grayscale image, but does so incorrectly-- the gray levels and alpha are wrong. Get around this by using composition to copy the source image over a slightly larger transparent image.
2017-04-12 15:53:18 +00:00
@convert $(IMOPS) "$<" -composite "PNG32:$@"
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
flag-symlinks: $(RESIZED_FLAG_FILES) | $(RENAMED_FLAGS_DIR)
Add GSUB substitutions to provide unknown flag for pairs of RIS. A current issue in Harfbuzz requires that you not perform a delete on index 1 before running a lookup on index 0.
2017-02-11 01:57:24 +00:00
@$(subst ^, , \
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(join \
$(FLAGS:%=ln^-fs^../resized_flags/%.png^), \
$(RENAMED_FLAG_FILES:%=%; ) \
) \
)
Update NotoColorEmoji template so that it passes lint, bump version. - fix ascent/descent in hhea and os/2 to match noto UI expectations, zero linegap, clear useTypoMetrics bit, set weight to regular (400). - add missing entries to name table, update revision - map U+0000 to null glyph (not .notdef) In addition, this tweaks the Makefile in some small ways: - quiet zopflipng output somewhat (listen to your cpu fan to know that something's happening) :-) - make flag-symlinks target an order-only dependency (it was triggering quantize+compress even when images hadn't changed) - add comment about how to bypass make bug if multithread hangs
2015-12-01 01:49:52 +00:00
$(RENAMED_FLAG_FILES): | flag-symlinks
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(QUANTIZED_DIR)/%.png: $(RENAMED_FLAGS_DIR)/%.png $(PNGQUANT) | $(QUANTIZED_DIR)
Use quality param with optipng. When images are not processed due to not being able to meet the minimum quality setting, error 99 is returned, so catch this too so we still copy the file. Might still want to tweak these settings.
2017-04-12 16:00:01 +00:00
@($(PNGQUANT) $(PNGQUANTFLAGS) -o "$@" "$<"; case "$$?" in "98"|"99") echo "reuse $<"; cp $< $@;; *) exit "$$?";; esac)
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(QUANTIZED_DIR)/%.png: $(EMOJI_DIR)/%.png $(PNGQUANT) | $(QUANTIZED_DIR)
Use quality param with optipng. When images are not processed due to not being able to meet the minimum quality setting, error 99 is returned, so catch this too so we still copy the file. Might still want to tweak these settings.
2017-04-12 16:00:01 +00:00
@($(PNGQUANT) $(PNGQUANTFLAGS) -o "$@" "$<"; case "$$?" in "98"|"99") echo "reuse $<";cp $< $@;; *) exit "$$?";; esac)
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(COMPRESSED_DIR)/%.png: $(QUANTIZED_DIR)/%.png | check_compress_tool $(COMPRESSED_DIR)
ifdef MISSING_ZOPFLI
Quiet makefile output.
2017-04-12 15:59:16 +00:00
@$(OPTIPNG) -quiet -o7 -clobber -force -out "$@" "$<"
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
else
Quiet makefile output.
2017-04-12 15:59:16 +00:00
@$(ZOPFLIPNG) -y "$<" "$@" 1> /dev/null 2>&1
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
endif
Update NotoColorEmoji template so that it passes lint, bump version. - fix ascent/descent in hhea and os/2 to match noto UI expectations, zero linegap, clear useTypoMetrics bit, set weight to regular (400). - add missing entries to name table, update revision - map U+0000 to null glyph (not .notdef) In addition, this tweaks the Makefile in some small ways: - quiet zopflipng output somewhat (listen to your cpu fan to know that something's happening) :-) - make flag-symlinks target an order-only dependency (it was triggering quantize+compress even when images hadn't changed) - add comment about how to bypass make bug if multithread hangs
2015-12-01 01:49:52 +00:00
# Make 3.81 can endless loop here if the target is missing but no
# prerequisite is updated and make has been invoked with -j, e.g.:
# File `font' does not exist.
# File `NotoColorEmoji.tmpl.ttx' does not exist.
# File `font' does not exist.
# File `NotoColorEmoji.tmpl.ttx' does not exist.
# ...
# Run make without -j if this happens.
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
%.ttx: %.ttx.tmpl $(ADD_GLYPHS) $(ALL_COMPRESSED_FILES)
Rewrite add_glyphs, use alias table. This is a rewrite of add_glyphs in third_party/color_emoji. The primary motivation was to move special aliasing rules out of that code and use an external aliases file instead. This new version is a bit more thorough about aliasing, and hopefully a little easier to read. The new add_glyphs takes its parameters using keywords, so the invocation in the Makefile changed (as well as the path to the tool). emoji_aliases.txt was extended to add the flag aliases that were formerly defined in the old add_glyphs code. add_aliases was modified so the name of the alias file could be passed in as a parameter to the main utility function that reads the alias mapping from the file. The new code expects all glyphs used by the template GSUB tables to be named in the GlyphOrder table, but doesn't require the cmap and hmtx table to be fleshed out. The new code fleshes these out when it processes the sequences to add. As a result the cmap and hmtx tables in the template were truncated. The new code also sorts the GlyphOrder table when it extends/rebuilds it.
2017-02-18 02:59:05 +00:00
@python $(ADD_GLYPHS) -f "$<" -o "$@" -d "$(COMPRESSED_DIR)" $(ADD_GLYPHS_FLAGS)
updates to support tr51 emoji sequences
2015-11-05 19:15:15 +00:00
Add the sources of the color emoji font.
2014-07-09 07:20:14 +00:00
%.ttf: %.ttx
@rm -f "$@"
ttx "$<"
Remove VS_ADDER as a dependency since it is not local
2015-10-15 00:26:44 +00:00
$(EMOJI).ttf: $(EMOJI).tmpl.ttf $(EMOJI_BUILDER) $(PUA_ADDER) \
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
$(ALL_COMPRESSED_FILES) | check_vs_adder
@python $(EMOJI_BUILDER) -V $< "$@" "$(COMPRESSED_DIR)/emoji_u"
@python $(PUA_ADDER) "$@" "$@-with-pua"
Quiet makefile output.
2017-04-12 15:59:16 +00:00
@$(VS_ADDER) -vs 2640 2642 2695 --dstdir '.' -o "$@-with-pua-varsel" "$@-with-pua"
@mv "$@-with-pua-varsel" "$@"
@rm "$@-with-pua"
Add the sources of the color emoji font.
2014-07-09 07:20:14 +00:00
clean:
Rename variables in Makefile.
2014-07-10 04:04:19 +00:00
rm -f $(EMOJI).ttf $(EMOJI).tmpl.ttf $(EMOJI).tmpl.ttx
Add flags for 200+ regions. This change also reorganized how the NotoColorEmoji font is created.
2014-08-13 02:28:00 +00:00
rm -f waveflag
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
rm -rf $(BUILD_DIR)
.SECONDARY: $(EMOJI_FILES) $(FLAG_FILES) $(RESIZED_FLAG_FILES) $(RENAMED_FLAG_FILES) \
Add GSUB substitutions to provide unknown flag for pairs of RIS. A current issue in Harfbuzz requires that you not perform a delete on index 1 before running a lookup on index 0.
2017-02-11 01:57:24 +00:00
$(ALL_QUANTIZED_FILES) $(ALL_COMPRESSED_FILES)
Rewrite makefile Change the build process to provide more intermediate steps and maintain intermediate targets. This slows down make's analysis phase, though. Make can be run with -j to parallelize the building, but be careful with multiple targets on the command line (e.g. 'make clean font') since clean's deletion of the output tree can sometimes occur after some of the output directories get built. This is preparatory to replacing the png images with the original internal set. These require a bit more cleanup and processing, which is what these changes do. The overall flow is: - convert all emoji to desired size (136x128). All are smaller than this, most are 128x128 but there are some others. - run waveflag on the flags - convert all flags to desired size(136x128). The flags are 128x128 originally. - 'rename' the flags by creating softlinks with the desired names - run pngquant on all the images and copy them into a single directory, this reduces slight antialiasing differences. - compress all the images, using zopflipng if available, else optipng. zopflipng saves about 10%, but is 10x slower. The remaining steps of building the font are unchanged, for the moment. The intermediate image files are put into a 'build' subdirectory to organize them and keep them out of the way.
2015-11-14 01:35:50 +00:00
.PHONY: clean flags emoji renamed_flags quantized compressed check_compress_tool