java.lang.Object

com.github.tommyettinger.textra.KnownFonts

All Implemented Interfaces:: com.badlogic.gdx.LifecycleListener

public final class KnownFonts
extends java.lang.Object
implements com.badlogic.gdx.LifecycleListener

Preconfigured static Font instances, with any important metric adjustments already applied. This uses a singleton to ensure each font exists at most once, and implements LifecycleListener to ensure that when the disposal stage of the lifecycle is called, then all Font instances here will be disposed and assigned null. This may do more regarding its LifecycleListener code in the future, if Android turns out to need more work.
Typical usage involves calling one of the static methods like getCozette() or getGentiumSDF() to get a particular Font. This knows a fair amount of fonts, but it doesn't require the image assets for all of those to be present in a game -- only the files mentioned in the documentation for a method are needed, and only if you call that method. It's likely that many games would only use one Font, and so would generally only need a .fnt file, a .png file, and some kind of license file. They could ignore all other assets required by other fonts. The files this class needs are looked for in the assets root folder by default, but you can change the names or locations of asset files with setAssetPrefix(String).
There's some documentation for every known Font, including a link to a preview image and a listing of all required files to use a Font. The required files include any license you need to abide by; this doesn't necessarily belong in the assets folder like the rest of the files! Most of these fonts are either licensed under the OFL or some Creative Commons license; the CC ones typically require attribution, but none of the fonts restrict usage to noncommercial projects, and all are free as in beer as well. Please take care to attribute the authors of fonts you use! Good fonts are not easy to make.
There are some special features in Font that are easier to use with parts of this class. getStandardFamily() pre-populates a FontFamily so you can switch between different fonts with the [@Sans] syntax. addEmoji(Font) adds all of Twitter's emoji from the Twemoji project to a given font, which lets you enter emoji with the [+man scientist, dark skin tone] syntax or the generally-easier [+👨🏿‍🔬] syntax. If you want to use names for emoji, you may want to consult "Twemoji.atlas" for the exact names used; some names changed from the standard because of technical restrictions. You can also add the icons from game-icons.net using addGameIcons(Font). There is a preview site for Twemoji, with names, and another preview site for the game icons.

Method Summary

Modifier and Type	Method	Description
`static Font`	`addEmoji(Font changing)`	Takes a Font and adds the Twemoji icon set to it, making the glyphs available using `[+name]` syntax.
`static Font`	`addEmoji(Font changing, float offsetXChange, float offsetYChange, float xAdvanceChange)`	Takes a Font and adds the Twemoji icon set to it, making the glyphs available using `[+name]` syntax.
`static Font`	`addEmoji(Font changing, java.lang.String prepend, java.lang.String append, float offsetXChange, float offsetYChange, float xAdvanceChange)`	Takes a Font and adds the Twemoji icon set to it, making the glyphs available using `[+name]` syntax.
`static Font`	`addGameIcons(Font changing)`	Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using `[+name]` syntax.
`static Font`	`addGameIcons(Font changing, float offsetXChange, float offsetYChange, float xAdvanceChange)`	Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using `[+name]` syntax.
`static Font`	`addGameIcons(Font changing, java.lang.String prepend, java.lang.String append, float offsetXChange, float offsetYChange, float xAdvanceChange)`	Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using `[+name]` syntax.
`void`	`dispose()`
`static Font[]`	`getAll()`	Returns a new array of Font instances, calling each getXyz() method in this class that returns any Font.
`static Font[]`	`getAllMSDF()`	Returns a new array of Font instances, calling each getXyz() method in this class that returns any MSDF Font.
`static Font[]`	`getAllSDF()`	Returns a new array of Font instances, calling each getXyz() method in this class that returns any SDF Font.
`static Font[]`	`getAllStandard()`	Returns a new array of Font instances, calling each getXyz() method in this class that returns any non-distance-field Font.
`static Font`	`getAStarry()`	Returns a very large fixed-width Font already configured to use a square font with 45-degree angled sections, based on the typeface used on the Atari ST console.
`static Font`	`getAStarryMSDF()`	Returns a Font already configured to use a square font with 45-degree angled sections, based on the typeface used on the Atari ST console, that should scale cleanly to many sizes.
`static Font`	`getBitter()`	Returns a Font already configured to use a light-weight variable-width slab serif font with good Latin and Cyrillic script support, that should scale pretty well from a height of about 160 down to a height of maybe 30.
`static Font`	`getCanada()`	Returns a Font already configured to use a very-legible variable-width font with strong support for Canadian Aboriginal Syllabic, that should scale pretty well from a height of about 86 down to a height of maybe 30.
`static Font`	`getCascadiaMono()`	Returns a Font already configured to use a quirky fixed-width font with good Unicode support and a humanist style, that should scale well from a height of about 60 pixels to about 15 pixels.
`static Font`	`getCascadiaMonoMSDF()`	Returns a Font already configured to use a quirky fixed-width font with good Unicode support and a humanist style, that should scale cleanly to even very large sizes (using an MSDF technique).
`static Font`	`getCaveat()`	Returns a Font already configured to use a variable-width handwriting font with support for extended Latin and Cyrillic, that should scale pretty well from a height of about 160 down to a height of maybe 20.
`static Font`	`getCozette()`	Returns a Font configured to use a cozy fixed-width bitmap font, Cozette by slavfox.
`static Font`	`getDejaVuSansMono()`	A nice old standby font with very broad language support, DejaVu Sans Mono is fixed-width and can be clearly readable but doesn't do anything unusual stylistically.
`static Font`	`getGameIconsFont(float width, float height)`	Gets a typically-square Font that is meant to be used in a FontFamily, allowing switching to a Font with the many game-icons.net icons.
`static Font`	`getGentium()`	Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale well from a height of about 132 down to a height of 34.
`static Font`	`getGentiumMSDF()`	Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale cleanly to even very large sizes (using an MSDF technique).
`static Font`	`getGentiumSDF()`	Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale cleanly to even very large sizes (using an SDF technique).
`static Font`	`getGentiumUnItalic()`	Returns a Font already configured to use a variable-width "italic-like" serif font with excellent Unicode support, that should scale well from a height of about 97 down to a height of 30.
`static Font`	`getGoNotoUniversal()`	Returns a Font already configured to use a variable-width sans-serif font with extreme pan-Unicode support, that should scale cleanly to medium-small sizes (but not large sizes).
`static Font`	`getGoNotoUniversalSDF()`	Returns a Font already configured to use a variable-width sans-serif font with extreme pan-Unicode support, that should scale cleanly to even very large sizes (using an SDF technique).
`static Font`	`getHanazono()`	Returns a Font already configured to use a variable-width, narrow font with nearly-complete CJK character coverage, plus Latin, Greek, and Cyrillic, that should scale pretty well down, but not up.
`static Font`	`getIBM8x16()`	Returns a Font configured to use a classic, nostalgic fixed-width bitmap font, IBM 8x16 from the early, oft-beloved computer line.
`static Font`	`getInconsolata()`	A customized version of Inconsolata LGC, a fixed-width geometric font that supports a large range of Latin, Greek, and Cyrillic glyphs, plus box drawing and some dingbat characters (like zodiac signs).
`static Font`	`getInconsolataMSDF()`	A customized version of Inconsolata LGC, a fixed-width geometric font that supports a large range of Latin, Greek, and Cyrillic glyphs, plus box drawing and some dingbat characters (like zodiac signs).
`static Font`	`getIosevka()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style.
`static Font`	`getIosevkaMSDF()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style, that should scale cleanly to even very large sizes (using an MSDF technique).
`static Font`	`getIosevkaSDF()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style, that should scale cleanly to fairly large sizes (using an SDF technique).
`static Font`	`getIosevkaSlab()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style.
`static Font`	`getIosevkaSlabMSDF()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style, that should scale cleanly to even very large sizes (using an MSDF technique).
`static Font`	`getIosevkaSlabSDF()`	Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style, that should scale cleanly to fairly large sizes (using an SDF technique).
`static Font`	`getKingthingsFoundation()`	Returns a Font already configured to use a fairly-legible variable-width ornamental/medieval font, that should scale pretty well from a height of about 90 down to a height of maybe 30.
`static Font`	`getKingthingsPetrock()`	Returns a Font already configured to use a clearly-legible variable-width medieval font, that should scale pretty well from a height of about 90 down to a height of maybe 30.
`static Font`	`getLanaPixel()`	Returns a Font already configured to use a variable-width pixel font with excellent Unicode support, that probably should only be used at integer multiples of its normal size.
`static Font`	`getLibertinusSerif()`	Returns a Font already configured to use a variable-width serif font with good Unicode support, that should scale cleanly to fairly large sizes or down to about 20 pixels.
`static Font`	`getNowAlt()`	Returns a Font already configured to use a variable-width geometric sans-serif font, that should scale cleanly to fairly large sizes or down to about 20 pixels.
`static Font`	`getOpenSans()`	Returns a Font configured to use a clean variable-width font, Open Sans.
`static Font`	`getOxanium()`	Returns a Font already configured to use a variable-width "science-fiction/high-tech" font, that should scale pretty well down, but not up.
`static Font`	`getQuanPixel()`	Returns a Font configured to use a small variable-width bitmap font with extensive coverage of Asian scripts, QuanPixel.
`static Font`	`getRobotoCondensed()`	Returns a Font already configured to use a very-legible condensed variable-width font with excellent Unicode support, that should scale pretty well from a height of about 62 down to a height of maybe 20.
`static Font`	`getStandardFamily()`	Returns a Font (`getGentium()`) with a FontFamily configured so that all non-distance-field Fonts can be used with syntax like `[@Sans]`.
`static Font`	`getTangerine()`	Returns a Font already configured to use a variable-width script font, that should scale pretty well down, but not up.
`static Font`	`getTangerineSDF()`	Returns a Font already configured to use a variable-width script font, that should scale pretty well down, but not up.
`static Font`	`getYanoneKaffeesatz()`	Returns a Font already configured to use a variable-width, narrow, humanist font, that should scale pretty well down, but not up.
`static Font`	`getYanoneKaffeesatzMSDF()`	Returns a Font already configured to use a variable-width, narrow, humanist font, that should scale very well up or down, but isn't compatible with inline images such as `emoji`.
`static Font`	`getYataghanMSDF()`	Returns a Font already configured to use a variable-width, narrow, "dark fantasy" font, that should scale very well up or down, but isn't compatible with inline images such as `emoji`.
`void`	`pause()`
`void`	`resume()`
`static void`	`setAssetPrefix(java.lang.String prefix)`	Changes the String prepended to each filename this looks up.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- setAssetPrefix
  
  public static void setAssetPrefix(java.lang.String prefix)
  
  Changes the String prepended to each filename this looks up. This should end in "/" if the files have the same name but are in a subdirectory (don't use backslashes for paths; they aren't cross-platform compatible). It can end without a "/" to prepend a String to the name of each file this looks up. The default prefix is "".
  
  Parameters:
  
  prefix - the new prefix to use before each filename, such as a subdirectory ending in "/"
- getAStarry
  
  public static Font getAStarry()
  Returns a very large fixed-width Font already configured to use a square font with 45-degree angled sections, based on the typeface used on the Atari ST console. This font only supports ASCII, but it supports all of it. Caches the result for later calls. The font is "a-starry", based on "Atari ST (low-res)" by Damien Guard; it is available under a CC-BY-SA-3.0 license, which requires attribution to Damien Guard (and technically Tommy Ettinger, because he made changes in a-starry) if you use it.
  Preview: Image link (uses width=8, height=8)
  This also looks good if you scale it so its height is twice its width. For small sizes, you should stick to multiples of 8. This "A Starry Tall" version is present in getAll() and getAllStandard().
  Preview: Image link (uses width=8, height=16)
  Needs files:
  
  AStarry-standard.fnt
  
  AStarry-standard.png
  
  AStarry-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font A Starry
- getAStarryMSDF
  
  public static Font getAStarryMSDF()
  Returns a Font already configured to use a square font with 45-degree angled sections, based on the typeface used on the Atari ST console, that should scale cleanly to many sizes. This font only supports ASCII, but it supports all of it. Caches the result for later calls. The font is "a-starry", based on "Atari ST (low-res)" by Damien Guard; it is available under a CC-BY-SA-3.0 license, which requires attribution to Damien Guard (and technically Tommy Ettinger, because he made changes in a-starry) if you use it. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  If you only need sizes in small integer multiples of 8 pixels, you might get sharper-looking results from getAStarry().
  Preview: Image link (uses width=10, height=10, crispness=2.0)
  Needs files:
  
  AStarry-msdf.fnt
  
  AStarry-msdf.png
  
  AStarry-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font A Starry using MSDF
- getBitter
  
  public static Font getBitter()
  Returns a Font already configured to use a light-weight variable-width slab serif font with good Latin and Cyrillic script support, that should scale pretty well from a height of about 160 down to a height of maybe 30. Caches the result for later calls. The font used is Bitter, a free (OFL) typeface by The Bitter Project. It supports quite a lot of Latin-based scripts and Cyrillic, but does not really cover Greek or any other scripts. This font can look good at its natural size, which uses width roughly equal to height, or squashed so height is slightly smaller. Bitter looks very similar to getGentium(), except that Bitter is quite a bit lighter, with thinner strokes and stylistic flourishes on some glyphs. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=33, height=30)
  Needs files:
  
  Bitter-standard.fnt
  
  Bitter-standard.png
  
  Bitter-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Bitter-Light.ttf
- getCanada
  
  public static Font getCanada()
  Returns a Font already configured to use a very-legible variable-width font with strong support for Canadian Aboriginal Syllabic, that should scale pretty well from a height of about 86 down to a height of maybe 30. Caches the result for later calls. The font used is Canada1500, a free (public domain, via CC0) typeface by Ray Larabie. It supports quite a lot of Latin-based scripts, Greek, Cyrillic, Canadian Aboriginal Syllabic, arrows, many dingbats, and more. This font can look good at its natural size, which uses width roughly equal to height, or narrowed down so width is smaller. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=30, height=35)
  Needs files:
  
  Canada1500-standard.fnt
  
  Canada1500-standard.png
  
  Canada1500-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Canada1500.ttf
- getCascadiaMono
  
  public static Font getCascadiaMono()
  Returns a Font already configured to use a quirky fixed-width font with good Unicode support and a humanist style, that should scale well from a height of about 60 pixels to about 15 pixels. Caches the result for later calls. The font used is Cascadia Code Mono, an open-source (SIL Open Font License) typeface by Microsoft (see Microsoft's page). It supports a lot of glyphs, including most extended Latin, Greek, Braille, and Cyrillic. This uses a fairly-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=10, height=20)
  Needs files:
  
  CascadiaMono-standard.fnt
  
  CascadiaMono-standard.png
  
  Cascadia-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Cascadia Code Mono
- getCascadiaMonoMSDF
  
  public static Font getCascadiaMonoMSDF()
  Returns a Font already configured to use a quirky fixed-width font with good Unicode support and a humanist style, that should scale cleanly to even very large sizes (using an MSDF technique). Caches the result for later calls. The font used is Cascadia Code Mono, an open-source (SIL Open Font License) typeface by Microsoft (see Microsoft's page). It supports a lot of glyphs, including most extended Latin, Greek, Braille, and Cyrillic. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses width=10, height=20)
  Needs files:
  
  CascadiaMono-msdf.fnt
  
  CascadiaMono-msdf.png
  
  Cascadia-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Cascadia Code Mono using MSDF
- getCaveat
  
  public static Font getCaveat()
  Returns a Font already configured to use a variable-width handwriting font with support for extended Latin and Cyrillic, that should scale pretty well from a height of about 160 down to a height of maybe 20. It will look sharper and more aliased at smaller sizes, but should be relatively smooth at a height of 32 or so. This is a sort of natural handwriting, as opposed to the formal script in getTangerine(). Caches the result for later calls. The font used is Caveat, a free (OFL) typeface designed by Pablo Impallari. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=32, height=32)
  Needs files:
  
  Caveat-standard.fnt
  
  Caveat-standard.png
  
  Caveat-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Caveat.ttf
- getCozette
  
  public static Font getCozette()
  Returns a Font configured to use a cozy fixed-width bitmap font, Cozette by slavfox. Cozette has broad coverage of Unicode, including Greek, Cyrillic, Braille, and tech-related icons. This does not scale well except to integer multiples, but it should look very crisp at its default size of 6x17 pixels. This defaults to having Font.integerPosition set to true, which currently does nothing (the code that enforces integer positions seems to ruin the appearance of any font that uses it, so that code isn't ever used now). This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=6, height=17; this size is small enough to make the scaled text unreadable in some places)
  Needs files:
  
  Cozette-standard.fnt
  
  Cozette-standard.png
  
  Cozette-License.txt
  Returns:
  
  the Font object that represents the 6x17px font Cozette
- getDejaVuSansMono
  
  public static Font getDejaVuSansMono()
  A nice old standby font with very broad language support, DejaVu Sans Mono is fixed-width and can be clearly readable but doesn't do anything unusual stylistically. It really does handle a lot of glyphs; not only does this have practically all Latin glyphs in Unicode (enough to support everything from Icelandic to Vietnamese), it has Greek (including Extended), Cyrillic (including some optional glyphs), IPA, Armenian (maybe the only font here to do so), Georgian (which won't be treated correctly by some case-insensitive code, so it should only be used if case doesn't matter), and Lao. It has full box drawing and Braille support, handles a wide variety of math symbols, technical marks, and dingbats, etc. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses width=9, height=20, crispness=2.0)
  Needs files:
  
  DejaVuSansMono-msdf.fnt
  
  DejaVuSansMono-msdf.png
  
  DejaVuSansMono-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font DejaVu Sans Mono using MSDF
- getGentium
  
  public static Font getGentium()
  Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale well from a height of about 132 down to a height of 34. Caches the result for later calls. The font used is Gentium, an open-source (SIL Open Font License) typeface by SIL (see SIL's page on Gentium here). It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic, as well as some less-common glyphs from various real languages. This does not use a distance field effect, as opposed to getGentiumSDF() or getGentiumMSDF(). You may want to stick using just fonts that avoid distance fields if you have a family of fonts. You can also use getStandardFamily() to obtain a variant on this Font that has a FontFamily already.
  Preview: Image link (uses width=31, height=35)
  Needs files:
  
  Gentium-standard.fnt
  
  Gentium-standard.png
  
  Gentium-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Gentium.ttf
- getGentiumMSDF
  
  public static Font getGentiumMSDF()
  Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale cleanly to even very large sizes (using an MSDF technique). You usually will want to reduce the line height of this Font after you scale it; using KnownFonts.getGentiumMSDF().scaleTo(50, 45).adjustLineHeight(0.625f) usually works. Caches the result for later calls. The font used is Gentium, an open-source (SIL Open Font License) typeface by SIL (see SIL's page on Gentium here). It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic, as well as some less-common glyphs from various real languages. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses width=50, height=45, adjustLineHeight(0.625f), setCrispness(3f))
  Needs files:
  
  Gentium-msdf.fnt
  
  Gentium-msdf.png
  
  Gentium-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Gentium.ttf using MSDF
- getGentiumSDF
  
  public static Font getGentiumSDF()
  Returns a Font already configured to use a variable-width serif font with excellent Unicode support, that should scale cleanly to even very large sizes (using an SDF technique). You usually will want to reduce the line height of this Font after you scale it; using KnownFonts.getGentiumSDF().scaleTo(50, 45).adjustLineHeight(0.625f) usually works. Caches the result for later calls. The font used is Gentium, an open-source (SIL Open Font License) typeface by SIL (see SIL's page on Gentium here). It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic, as well as some less-common glyphs from various real languages. This uses the Signed Distance Field (SDF) technique, which may be slightly fuzzy when zoomed in heavily, but should be crisp enough when zoomed out.
  Preview: Image link (uses width=50, height=45, adjustLineHeight(0.625f), setCrispness(1.5f))
  Needs files:
  
  Gentium-sdf.fnt
  
  Gentium-sdf.png
  
  Gentium-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Gentium.ttf using SDF
- getGentiumUnItalic
  
  public static Font getGentiumUnItalic()
  Returns a Font already configured to use a variable-width "italic-like" serif font with excellent Unicode support, that should scale well from a height of about 97 down to a height of 30. Caches the result for later calls. The font used is Gentium, an open-source (SIL Open Font License) typeface by SIL (see SIL's page on Gentium here), but this took Gentium Italic and removed the 8-degree slant it had, so it looks like a regular face but with the different serif style and the "flow" of an italic font. This helps it look closer to carefully-hand-written text mixed with a serif typeface, and may fit well as a main-text font for medieval or Renaissance-period games while something like getKingthingsFoundation() is used for titles or headers. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic, as well as some less-common glyphs from various real languages. Even though glyphs are not especially wide here, this Font does need to be configured with a much larger width than height to be readable. This does not use a distance field effect. You may want to stick using just fonts that avoid distance fields if you have a family of fonts.
  Thanks to Siavash Ranbar, who came up with the idea to take an italic version of a serif font and remove its slant, keeping the different flow from a simple oblique font.
  Preview: Image link (uses width=60, height=36)
  Needs files:
  
  GentiumUnItalic-standard.fnt
  
  GentiumUnItalic-standard.png
  
  Gentium-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Gentium-Un-Italic.ttf
- getGoNotoUniversal
  
  public static Font getGoNotoUniversal()
  Returns a Font already configured to use a variable-width sans-serif font with extreme pan-Unicode support, that should scale cleanly to medium-small sizes (but not large sizes). Caches the result for later calls. The font used is Go Noto Universal, an open-source (SIL Open Font License) typeface that modifies Noto Sans by Google (see Go Noto Universal's page is here, and Noto Fonts have a page here). It supports... most glyphs, from many languages, including essentially all extended Latin, Greek, Cyrillic, Chinese, Japanese, Armenian, Ethiopic, Cherokee, Javanese... Most scripts are here, though not Hangul (used for Korean). This also has symbols for math, music, and other usage. Unlike the SDF version, the standard version should have a stable baseline. The texture this uses is larger than many of the others here, at 4096x4096 pixels, but the file isn't too large; in fact, the 2048x2048 textures Gentium-msdf.png and Twemoji.png are each larger than GoNotoUniversal-standard.png . The .fnt has 21274 glyphs plus extensive kerning info, though, so it is large.
  Preview: Image link (uses width=66, height=33)
  Needs files:
  
  GoNotoUniversal-standard.fnt
  
  GoNotoUniversal-standard.png
  
  GoNotoUniversal-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font GoNotoCurrent.ttf using SDF
- getGoNotoUniversalSDF
  
  public static Font getGoNotoUniversalSDF()
  Returns a Font already configured to use a variable-width sans-serif font with extreme pan-Unicode support, that should scale cleanly to even very large sizes (using an SDF technique). Caches the result for later calls. The font used is Go Noto Universal, an open-source (SIL Open Font License) typeface that modifies Noto Sans by Google (see Go Noto Universal's page is here, and Noto Fonts have a page here). It supports... most glyphs, from many languages, including essentially all extended Latin, Greek, Cyrillic, Chinese, Japanese, Armenian, Ethiopic, Cherokee, Javanese... Most scripts are here, though not Hangul (used for Korean). This also has symbols for math, music, and other usage. The baseline may be slightly uneven at larger sizes, but should even out when height is less than 40 or so. This uses the Signed Distance Field (SDF) technique, which may be slightly fuzzy when zoomed in heavily, but should be crisp enough when zoomed out. The texture this uses is larger than many of the others here, at 4096x4096 pixels, but the file isn't too large; in fact, the 2048x2048 textures Gentium-msdf.png and Twemoji.png are each larger than GoNotoUniversal-sdf.png . The .fnt has 24350 glyphs plus extensive kerning info, though, so it is quite large.
  A quirk of this particular .fnt file is that it uses features specific to TextraTypist; as far as I know, it cannot be read by the libGDX BitmapFont class. These features are simply how it stores metric values -- as float, rather than only as int. You should probably not try to load GoNotoUniversal-sdf.fnt with BitmapFont or DistanceFieldFont in libGDX. Using floats is very helpful for the distance field effect; without them, most glyphs would render slightly off from the intended position, due to rounding to an int instead of using a float.
  Preview: Image link (uses width=43.25, height=34, setCrispness(1.8f))
  Needs files:
  
  GoNotoUniversal-sdf.fnt
  
  GoNotoUniversal-sdf.png
  
  GoNotoUniversal-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font GoNotoCurrent.ttf using SDF
- getHanazono
  
  public static Font getHanazono()
  Returns a Font already configured to use a variable-width, narrow font with nearly-complete CJK character coverage, plus Latin, Greek, and Cyrillic, that should scale pretty well down, but not up. Caches the result for later calls. The font used is Hanazono (HanMinA, specifically), a free (OFL) typeface. This uses a somewhat-small standard bitmap font because of how many glyphs are present (over 34000); it might not scale as well as other standard bitmap fonts here. You may want to consider getGoNotoUniversalSDF() if you can use an SDF font, since it scales up with higher quality. Otherwise, this may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=16, height=20)
  Needs files:
  
  Hanazono-standard.fnt
  
  Hanazono-standard.png
  
  Hanazono-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font HanMinA.ttf
- getIBM8x16
  
  public static Font getIBM8x16()
  Returns a Font configured to use a classic, nostalgic fixed-width bitmap font, IBM 8x16 from the early, oft-beloved computer line. This font is notably loaded from a SadConsole format file, which shouldn't affect how it looks (but in reality, it might). This does not scale except to integer multiples, but it should look very crisp at its default size of 8x16 pixels. This supports some extra characters, but not at the typical Unicode codepoints. This defaults to having Font.integerPosition set to true, which currently does nothing (the code that enforces integer positions seems to ruin the appearance of any font that uses it, so that code isn't ever used now). This may work well in a font family with other fonts that do not use a distance field effect.
  This does not include a license because the source, SadConsole's fonts, did not include one. It is doubtful that IBM would have any issues with respectful use of their signature font throughout the 1980s, but if the legality is concerning, you can use getCozette() or getQuanPixel() for a different bitmap font. There is also getAStarry() for a non-pixel font styled after a font from the same era.
  Preview: Image link (uses width=8, height=16, done with fitCell(8, 16, false))
  Needs files:
  
  IBM-8x16-standard.font
  
  IBM-8x16-standard.png
  Returns:
  
  the Font object that represents an 8x16 font included with early IBM computers
- getInconsolata
  
  public static Font getInconsolata()
  A customized version of Inconsolata LGC, a fixed-width geometric font that supports a large range of Latin, Greek, and Cyrillic glyphs, plus box drawing and some dingbat characters (like zodiac signs). The original font Inconsolata is by Raph Levien, and various other contributors added support for other languages. This does not use a distance field effect, as opposed to getInconsolataMSDF(). This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=10, height=26)
  Needs files:
  
  Inconsolata-LGC-Custom-standard.fnt
  
  Inconsolata-LGC-Custom-standard.png
  
  Inconsolata-LGC-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Inconsolata LGC Custom
- getInconsolataMSDF
  
  public static Font getInconsolataMSDF()
  A customized version of Inconsolata LGC, a fixed-width geometric font that supports a large range of Latin, Greek, and Cyrillic glyphs, plus box drawing and some dingbat characters (like zodiac signs). The original font Inconsolata is by Raph Levien, and various other contributors added support for other languages. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses .scaleTo(12, 26).setCrispness(1.2f))
  Needs files:
  
  Inconsolata-LGC-Custom-msdf.fnt
  
  Inconsolata-LGC-Custom-msdf.png
  
  Inconsolata-LGC-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Inconsolata LGC Custom using MSDF
- getIosevka
  
  public static Font getIosevka()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style. Does not use a distance field effect, and is sized best at 9x25 pixels. Caches the result for later calls. The font used is Iosevka, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses .scaleTo(10, 24).fitCell(10, 24, false))
  Needs files:
  
  Iosevka-standard.fnt
  
  Iosevka-standard.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka.ttf
- getIosevkaMSDF
  
  public static Font getIosevkaMSDF()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style, that should scale cleanly to even very large sizes (using an MSDF technique). Caches the result for later calls. The font used is Iosevka, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes. However, using a distance field makes it effectively impossible to mix fonts using a FontFamily (any variation in distance field settings would make some fonts in the family blurry and others too sharp).
  Preview: Image link (uses .setCrispness(2.5f).scaleTo(12, 26).fitCell(10, 25, false))
  Needs files:
  
  Iosevka-msdf.fnt
  
  Iosevka-msdf.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka.ttf using MSDF
- getIosevkaSDF
  
  public static Font getIosevkaSDF()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a sans-serif geometric style, that should scale cleanly to fairly large sizes (using an SDF technique). Caches the result for later calls. The font used is Iosevka, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This uses the Signed Distance Field (SDF) technique as opposed to the Multi-channel Signed Distance Field technique that getIosevkaMSDF() uses, which isn't as sharp at large sizes but can look a little better at small sizes. However, using a distance field makes it effectively impossible to mix fonts using a FontFamily (any variation in distance field settings would make some fonts in the family blurry and others too sharp).
  Preview: Image link (uses .setCrispness(0.75f).scaleTo(12, 26).fitCell(10, 25, false))
  Needs files:
  
  Iosevka-sdf.fnt
  
  Iosevka-sdf.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka.ttf using SDF
- getIosevkaSlab
  
  public static Font getIosevkaSlab()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style. Does not use a distance field effect, and is sized best at 9x25 pixels. Caches the result for later calls. The font used is Iosevka with Slab style, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses .scaleTo(10, 24).fitCell(10, 24, false))
  Needs files:
  
  Iosevka-Slab-standard.fnt
  
  Iosevka-Slab-standard.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka-Slab.ttf
- getIosevkaSlabMSDF
  
  public static Font getIosevkaSlabMSDF()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style, that should scale cleanly to even very large sizes (using an MSDF technique). Caches the result for later calls. The font used is Iosevka with Slab style, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses .setCrispness(2.5f).scaleTo(12, 26).fitCell(10, 25, false))
  Needs files:
  
  Iosevka-Slab-msdf.fnt
  
  Iosevka-Slab-msdf.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka-Slab.ttf using MSDF
- getIosevkaSlabSDF
  
  public static Font getIosevkaSlabSDF()
  Returns a Font already configured to use a highly-legible fixed-width font with good Unicode support and a slab-serif geometric style, that should scale cleanly to fairly large sizes (using an SDF technique). Caches the result for later calls. The font used is Iosevka with Slab style, an open-source (SIL Open Font License) typeface by Belleve Invis, and it uses several customizations thanks to Iosevka's special build process. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This Font is already configured with Font.fitCell(float, float, boolean), and repeated calls to fitCell() have an unknown effect; you may want to stick to scaling this and not re-fitting if you encounter issues. This uses the Signed Distance Field (SDF) technique as opposed to the Multi-channel Signed Distance Field technique that getIosevkaSlabMSDF() uses, which isn't as sharp at large sizes but can look a little better at small sizes.
  Preview: Image link (uses .setCrispness(0.75f).scaleTo(12, 26).fitCell(10, 25, false))
  Needs files:
  
  Iosevka-Slab-sdf.fnt
  
  Iosevka-Slab-sdf.png
  
  Iosevka-License.md
  Returns:
  
  the Font object that can represent many sizes of the font Iosevka-Slab.ttf using SDF
- getKingthingsFoundation
  
  public static Font getKingthingsFoundation()
  Returns a Font already configured to use a fairly-legible variable-width ornamental/medieval font, that should scale pretty well from a height of about 90 down to a height of maybe 30. Caches the result for later calls. The font used is Kingthings Foundation, a free (custom permissive license) typeface; this has faux-bold applied already in order to make some ornamental curls visible at more sizes. You can still apply bold again using markup. It supports only ASCII. You may want to also look at Kingthings Petrock; where Petrock is less-ornamented, Foundation is heavily ornamented, and Foundation may make sense for text associated with writers of high social status. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses scaleTo(23, 31))
  Needs files:
  
  KingthingsFoundation-standard.fnt
  
  KingthingsFoundation-standard.png
  
  Kingthings-License.txt
  
  You may instead want the non-bold version, but this doesn't have a pre-made instance in KnownFonts:
  
  KingthingsFoundation-Light-standard.fnt
  
  KingthingsFoundation-Light-standard.png
  
  Kingthings-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font KingthingsFoundation.ttf
- getKingthingsPetrock
  
  public static Font getKingthingsPetrock()
  Returns a Font already configured to use a clearly-legible variable-width medieval font, that should scale pretty well from a height of about 90 down to a height of maybe 30. Caches the result for later calls. The font used is Kingthings Petrock, a free (custom permissive license) typeface; it has a visual style similar to one used by some popular classic rock bands. It supports only ASCII and a small amount of extended Latin. Kingthings Petrock is similar to Kingthings Foundation, but Petrock isn't as heavily-ornamented, and looks more like "every-day usable" medieval or maybe Renaissance text. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses scaleTo(25, 32))
  Needs files:
  
  KingthingsPetrock-standard.fnt
  
  KingthingsPetrock-standard.png
  
  Kingthings-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font KingthingsPetrock.ttf
- getLanaPixel
  
  public static Font getLanaPixel()
  Returns a Font already configured to use a variable-width pixel font with excellent Unicode support, that probably should only be used at integer multiples of its normal size. Caches the result for later calls. The font used is LanaPixel, an open-source (dual-licensed under the SIL Open Font License and Creative Commons Attribution License) typeface. It supports an incredible amount of glyphs, and is meant to allow localizing to just about any widely-used language. This uses a tiny standard bitmap font, and it can only be used as-is or scaled up by integer multiples. This defaults to having Font.integerPosition set to true, which currently does nothing (the code that enforces integer positions seems to ruin the appearance of any font that uses it, so that code isn't ever used now). This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=20, height=15)
  Needs files:
  
  LanaPixel-standard.fnt
  
  LanaPixel-standard.png
  
  LanaPixel-CCBYLicense.txt
  
  LanaPixel-OpenFontLicense.txt
  Returns:
  
  the Font object that can represent many sizes of the font LanaPixel.ttf
- getLibertinusSerif
  
  public static Font getLibertinusSerif()
  Returns a Font already configured to use a variable-width serif font with good Unicode support, that should scale cleanly to fairly large sizes or down to about 20 pixels. Caches the result for later calls. The font used is Libertinus Serif, an open-source (SIL Open Font License) typeface. It supports a lot of glyphs, including quite a bit of extended Latin, Greek, and Cyrillic. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect. Earlier versions of this font used an MSDF effect, but that doesn't work well with kerning, so the spacing between letters was odd, and in general the font just didn't look as good as the similar getGentiumSDF() or even getGentium(). The MSDF files are still present in the same directory where they were, but they are no longer used by TextraTypist.
  Preview: Image link (uses width=40, height=34)
  Needs files:
  
  LibertinusSerif-standard.fnt
  
  LibertinusSerif-standard.png
  
  LibertinusSerif-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font LibertinusSerif.ttf
- getNowAlt
  
  public static Font getNowAlt()
  Returns a Font already configured to use a variable-width geometric sans-serif font, that should scale cleanly to fairly large sizes or down to about 20 pixels. Caches the result for later calls. The font used is Now Alt, an open-source (SIL Open Font License) typeface by Hanken Design Co. It has decent glyph coverage for most European languages, but doesn't fully support Greek or Cyrillic. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=29, height=33)
  Needs files:
  
  Now-Alt-standard.fnt
  
  Now-Alt-standard.png
  
  Now-Alt-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font NowAlt.otf
- getOpenSans
  
  public static Font getOpenSans()
  Returns a Font configured to use a clean variable-width font, Open Sans. It has good extended-Latin coverage, but does not support Greek, Cyrillic, or other scripts. This makes an especially large font by default, but can be scaled down nicely. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses .scaleTo(20, 28))
  Needs files:
  
  OpenSans-standard.fnt
  
  OpenSans-standard.png
  
  OpenSans-License.txt
  Returns:
  
  the Font object that represents the variable-width font OpenSans
- getOxanium
  
  public static Font getOxanium()
  Returns a Font already configured to use a variable-width "science-fiction/high-tech" font, that should scale pretty well down, but not up. Caches the result for later calls. The font used is Oxanium, a free (OFL) typeface. It supports a lot of Latin and extended Latin, but not Greek or Cyrillic. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=31, height=35)
  Needs files:
  
  Oxanium-standard.fnt
  
  Oxanium-standard.png
  
  Oxanium-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Oxanium.ttf
- getQuanPixel
  
  public static Font getQuanPixel()
  Returns a Font configured to use a small variable-width bitmap font with extensive coverage of Asian scripts, QuanPixel. QuanPixel has good coverage of Unicode, including all of Greek, at least most of Cyrillic, a good amount of extended Latin, all of Katakana and Hiragana, many Hangul syllables, and literally thousands of CJK ideograms. This does not scale well except to integer multiples, but it should look very crisp at its default size of about 8 pixels tall with variable width. This defaults to having Font.integerPosition set to true, which currently does nothing (the code that enforces integer positions seems to ruin the appearance of any font that uses it, so that code isn't ever used now). This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=12, height=12; this size is small enough to make the scaled text unreadable in some places)
  Needs files:
  
  QuanPixel-standard.fnt
  
  QuanPixel-standard.png
  
  QuanPixel-License.txt
  Returns:
  
  the Font object that represents the 8px tall font QuanPixel
- getRobotoCondensed
  
  public static Font getRobotoCondensed()
  Returns a Font already configured to use a very-legible condensed variable-width font with excellent Unicode support, that should scale pretty well from a height of about 62 down to a height of maybe 20. Caches the result for later calls. The font used is Roboto Condensed, a free (Apache 2.0) typeface by Christian Robertson. It supports Latin-based scripts almost entirely, plus Greek, (extended) Cyrillic, and more. This font is meant to be condensed in its natural appearance, but can be scaled to be wider if desired. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=20, height=32)
  Needs files:
  
  RobotoCondensed-standard.fnt
  
  RobotoCondensed-standard.png
  
  RobotoCondensed-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font RobotoCondensed.ttf
- getTangerine
  
  public static Font getTangerine()
  Returns a Font already configured to use a variable-width script font, that should scale pretty well down, but not up. Caches the result for later calls. The font used is Tangerine, a free (OFL) typeface. It supports Latin only, with a little support for Western European languages, but not really anything else. It looks elegant, though. This uses a very-large standard bitmap font, which lets it be scaled down OK but not scaled up very well. Some sizes may look very sharply-aliased with this version of Tangerine, but getTangerineSDF() doesn't seem to have that problem. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=48, height=32)
  Needs files:
  
  Tangerine-standard.fnt
  
  Tangerine-standard.png
  
  Tangerine-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Tangerine.ttf
- getTangerineSDF
  
  public static Font getTangerineSDF()
  Returns a Font already configured to use a variable-width script font, that should scale pretty well down, but not up. Caches the result for later calls. The font used is Tangerine, a free (OFL) typeface. It supports Latin only, with a little support for Western European languages, but not really anything else. It looks elegant, though. This uses the Signed Distance Field (SDF) technique, which may be slightly fuzzy when zoomed in heavily, but should be crisp enough when zoomed out. If you need to mix in images such as with addEmoji(Font), you may be better off with getTangerine(), the standard-bitmap-font version.
  Preview: Image link (uses width=48, height=32, setCrispness(0.375f))
  Needs files:
  
  Tangerine-sdf.fnt
  
  Tangerine-sdf.png
  
  Tangerine-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Tangerine.ttf using SDF
- getYanoneKaffeesatz
  
  public static Font getYanoneKaffeesatz()
  Returns a Font already configured to use a variable-width, narrow, humanist font, that should scale pretty well down, but not up. Caches the result for later calls. The font used is Yanone Kaffeesatz, a free (OFL) typeface. It supports a lot of Latin, Cyrillic, and some extended Latin, but not Greek. This uses a very-large standard bitmap font, which lets it be scaled down nicely but not scaled up very well. This may work well in a font family with other fonts that do not use a distance field effect.
  Preview: Image link (uses width=26, height=30)
  Needs files:
  
  YanoneKaffeesatz-standard.fnt
  
  YanoneKaffeesatz-standard.png
  
  YanoneKaffeesatz-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font YanoneKaffeesatz.ttf
- getYanoneKaffeesatzMSDF
  
  public static Font getYanoneKaffeesatzMSDF()
  Returns a Font already configured to use a variable-width, narrow, humanist font, that should scale very well up or down, but isn't compatible with inline images such as emoji. Caches the result for later calls. The font used is Yanone Kaffeesatz, a free (OFL) typeface. It supports a lot of Latin, Cyrillic, and some extended Latin, but not Greek. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  Preview: Image link (uses width=26, height=30, setCrispness(2.5f))
  Needs files:
  
  YanoneKaffeesatz-msdf.fnt
  
  YanoneKaffeesatz-msdf.png
  
  YanoneKaffeesatz-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font YanoneKaffeesatz.ttf using MSDF
- getYataghanMSDF
  
  public static Font getYataghanMSDF()
  Returns a Font already configured to use a variable-width, narrow, "dark fantasy" font, that should scale very well up or down, but isn't compatible with inline images such as emoji. Caches the result for later calls. The font used is Yataghan, a widely-distributed typeface. It supports ASCII and some extended Latin, but not much else. This uses the Multi-channel Signed Distance Field (MSDF) technique as opposed to the normal Signed Distance Field technique, which gives the rendered font sharper edges and precise corners instead of rounded tips on strokes.
  I don't know who the original author of Yataghan was; if you are the original author and want attribution or want this font removed, please post an issue on the tommyettinger/textratypist GitHub repo, or email tommyettinger.
  Preview: Image link (uses width=20, height=32)
  Needs files:
  
  Yataghan-msdf.fnt
  
  Yataghan-msdf.png
  
  Yataghan-License.txt
  Returns:
  
  the Font object that can represent many sizes of the font Yataghan.ttf using MSDF
- addEmoji
  
  public static Font addEmoji(Font changing)
  Takes a Font and adds the Twemoji icon set to it, making the glyphs available using [+name] syntax. You can use the name of an emoji, such as [+clown face], or equivalently use the actual emoji, such as [+🤡], with the latter preferred because the names can be unwieldy or hard to get right. This caches the Twemoji atlas for later calls. This tries to load the files "Twemoji.atlas" and "Twemoji.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory.
  You can add emoji to a font as inline images with KnownFonts.addEmoji(Font). Emoji don't work at all with MSDF fonts, and don't support more than one color with SDF fonts, but work as intended with "standard" fonts (without a distance field effect). They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. There are over 3000 emoji in the Twemoji set, and they are accessible both by name, using the syntax [+clown face], and by entering the actual emoji, using the syntax [+🤡]. You can search for names in Twemoji.atlas, or use the emoji picker in Skin Composer to navigate by category. You can also use the emoji picker present in some OSes, such as how Win+. allows selecting an emoji on Windows 10 and up. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name or emoji, and Font.namesByCharCode to go from such an internal code to an emoji (as UTF-8).
  Note that there isn't enough available space in a Font to add both emoji with this and icons with addGameIcons(Font). You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  Preview: Image link (uses the font getAStarry() and [%?blacken] mode)
  You can see all emoji and the names they use at this GitHub Pages site.
  Needs files:
  
  Twemoji.atlas
  
  Twemoji.png
  
  Twemoji-License.txt
  Parameters:
  
  changing - a Font that will have over 3000 emoji added to it, with more aliases
  
  Returns:
  
  changing, after the emoji atlas has been added
- addEmoji
  
  public static Font addEmoji(Font changing, float offsetXChange, float offsetYChange, float xAdvanceChange)
  Takes a Font and adds the Twemoji icon set to it, making the glyphs available using [+name] syntax. You can use the name of an emoji, such as [+clown face], or equivalently use the actual emoji, such as [+🤡], with the latter preferred because the names can be unwieldy or hard to get right. This caches the Twemoji atlas for later calls. This tries to load the files "Twemoji.atlas" and "Twemoji.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory. There are over 3000 emoji in the Twemoji set; it requires attribution to use.
  Emoji don't work at all with MSDF fonts, and don't support more than one color with SDF fonts, but work as intended with "standard" fonts (without a distance field effect). They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. You can search for names in Twemoji.atlas, or use the emoji picker in Skin Composer to navigate by category. You can also use the emoji picker present in some OSes, such as how Win+. allows selecting an emoji on Windows 10 and up. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name or emoji, and Font.namesByCharCode to go from such an internal code to an emoji (as UTF-8).
  Note that there isn't enough available space in a Font to add both emoji with this and icons with addGameIcons(Font). You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  This overload allows customizing the x/y offsets and x-advance for every emoji this puts in a Font.
  Preview: Image link (uses the font getAStarry() and [%?blacken] mode)
  You can see all emoji and the names they use at this GitHub Pages site.
  Needs files:
  
  Twemoji.atlas
  
  Twemoji.png
  
  Twemoji-License.txt
  Parameters:
  
  changing - a Font that will have over 3000 emoji added to it, with more aliases
  
  offsetXChange - will be added to the Font.GlyphRegion.offsetX of each added glyph
  
  offsetYChange - will be added to the Font.GlyphRegion.offsetY of each added glyph
  
  xAdvanceChange - will be added to the Font.xAdvance(com.github.tommyettinger.textra.Font, float, long) of each added glyph
  
  Returns:
  
  changing, after the emoji atlas has been added
- addEmoji
  
  public static Font addEmoji(Font changing, java.lang.String prepend, java.lang.String append, float offsetXChange, float offsetYChange, float xAdvanceChange)
  Takes a Font and adds the Twemoji icon set to it, making the glyphs available using [+name] syntax. You can use the name of an emoji, such as [+clown face], or equivalently use the actual emoji, such as [+🤡], with the latter preferred because the names can be unwieldy or hard to get right. This caches the Twemoji atlas for later calls. This tries to load the files "Twemoji.atlas" and "Twemoji.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory. There are over 3000 emoji in the Twemoji set; it requires attribution to use.
  Emoji don't work at all with MSDF fonts, and don't support more than one color with SDF fonts, but work as intended with "standard" fonts (without a distance field effect). They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. You can search for names in Twemoji.atlas, or use the emoji picker in Skin Composer to navigate by category. You can also use the emoji picker present in some OSes, such as how Win+. allows selecting an emoji on Windows 10 and up. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name or emoji, and Font.namesByCharCode to go from such an internal code to an emoji (as UTF-8).
  Note that there isn't enough available space in a Font to add both emoji with this and icons with addGameIcons(Font). You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  This overload allows customizing the x/y offsets and x-advance for every emoji this puts in a Font. It also allows specifying Strings to prepend before and append after each name in the font, including emoji names.
  Preview: Image link (uses the font getAStarry() and [%?blacken] mode)
  You can see all emoji and the names they use at this GitHub Pages site.
  Needs files:
  
  Twemoji.atlas
  
  Twemoji.png
  
  Twemoji-License.txt
  Parameters:
  
  changing - a Font that will have over 3000 emoji added to it, with more aliases
  
  prepend - will be prepended before each name in the atlas; if null, will be treated as ""
  
  append - will be appended after each name in the atlas; if null, will be treated as ""
  
  offsetXChange - will be added to the Font.GlyphRegion.offsetX of each added glyph
  
  offsetYChange - will be added to the Font.GlyphRegion.offsetY of each added glyph
  
  xAdvanceChange - will be added to the Font.xAdvance(com.github.tommyettinger.textra.Font, float, long) of each added glyph
  
  Returns:
  
  changing, after the emoji atlas has been added
- addGameIcons
  
  public static Font addGameIcons(Font changing)
  Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using [+name] syntax. Unlike the emoji used by addEmoji(Font), icons here are always. retrieved by name, and names are always all-lower-case, separated by dashes ('-'). This caches the Game-Icons.net atlas for later calls. This tries to load the files "Game-Icons.atlas" and "Game-Icons.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory. There are 4131 images in this edition of the Game-Icons.net icons (from December 20, 2022), and it requires attribution to use.
  Although these icons might work with MSDF fonts, they should work with standard and SDF fonts. They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. All icons use only the color white with various levels of transparency, so they can be colored like normal text glyphs. You can search for names in Game-Icons.atlas. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name, and Font.namesByCharCode to go from such an internal code to the corresponding name.
  Note that there isn't enough available space in a Font to add both emoji with addEmoji(Font) and icons with this. You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  Preview: Image link (uses the font getNowAlt() and [%?blacken] mode)
  You can see all icons and the names they use at this GitHub Pages site.
  Needs files:
  
  Game-Icons.atlas
  
  Game-Icons.png
  
  Game-Icons-License.txt
  Parameters:
  
  changing - a Font that will have over 4000 icons added to it
  
  Returns:
  
  changing, after the icon atlas has been added
- addGameIcons
  
  public static Font addGameIcons(Font changing, float offsetXChange, float offsetYChange, float xAdvanceChange)
  Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using [+name] syntax. Unlike the emoji used by addEmoji(Font), icons here are always. retrieved by name, and names are always all-lower-case, separated by dashes ('-'). This caches the Game-Icons.net atlas for later calls. This tries to load the files "Game-Icons.atlas" and "Game-Icons.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory. There are 4131 images in this edition of the Game-Icons.net icons (from December 20, 2022), and it requires attribution to use.
  Although these icons might work with MSDF fonts, they should work with standard and SDF fonts. They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. All icons use only the color white with various levels of transparency, so they can be colored like normal text glyphs. You can search for names in Game-Icons.atlas. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name, and Font.namesByCharCode to go from such an internal code to the corresponding name.
  Note that there isn't enough available space in a Font to add both emoji with addEmoji(Font) and icons with this. You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  This overload allows customizing the x/y offsets and x-advance for every icon this puts in a Font.
  Preview: Image link (uses the font getNowAlt() and [%?blacken] mode)
  You can see all icons and the names they use at this GitHub Pages site.
  Needs files:
  
  Game-Icons.atlas
  
  Game-Icons.png
  
  Game-Icons-License.txt
  Parameters:
  
  changing - a Font that will have over 4000 icons added to it
  
  offsetXChange - will be added to the Font.GlyphRegion.offsetX of each added glyph
  
  offsetYChange - will be added to the Font.GlyphRegion.offsetY of each added glyph
  
  xAdvanceChange - will be added to the Font.xAdvance(com.github.tommyettinger.textra.Font, float, long) of each added glyph
  
  Returns:
  
  changing, after the icon atlas has been added
- addGameIcons
  
  public static Font addGameIcons(Font changing, java.lang.String prepend, java.lang.String append, float offsetXChange, float offsetYChange, float xAdvanceChange)
  Takes a Font and adds the Game-Icons.net icon set to it, making the glyphs available using [+name] syntax. Unlike the emoji used by addEmoji(Font), icons here are always. retrieved by name, and names are always all-lower-case, separated by dashes ('-'). This caches the Game-Icons.net atlas for later calls. This tries to load the files "Game-Icons.atlas" and "Game-Icons.png" from the internal storage first, and if that fails, it tries to load them from local storage in the current working directory. There are 4131 images in this edition of the Game-Icons.net icons (from December 20, 2022), and it requires attribution to use.
  Although these icons might work with MSDF fonts, they should work with standard and SDF fonts. They can scale reasonably well down, and less-reasonably well up, but at typical text sizes (12-30 pixels in height) they tend to be legible. All icons use only the color white with various levels of transparency, so they can be colored like normal text glyphs. You can search for names in Game-Icons.atlas. Programmatically, you can use Font.nameLookup to look up the internal char this uses for a given name, and Font.namesByCharCode to go from such an internal code to the corresponding name.
  Note that there isn't enough available space in a Font to add both emoji with addEmoji(Font) and icons with this. You can, however, make two copies of a Font, add emoji to one and icons to the other, and put both in a FontFamily, so you can access both atlases in the same block of text.
  This overload allows customizing the x/y offsets and x-advance for every icon this puts in a Font. It also allows specifying Strings to prepend before and append after each name in the font.
  Preview: Image link (uses the font getNowAlt() and [%?blacken] mode)
  You can see all icons and the names they use at this GitHub Pages site.
  Needs files:
  
  Game-Icons.atlas
  
  Game-Icons.png
  
  Game-Icons-License.txt
  Parameters:
  
  changing - a Font that will have over 4000 icons added to it
  
  prepend - will be prepended before each name in the atlas; if null, will be treated as ""
  
  append - will be appended after each name in the atlas; if null, will be treated as ""
  
  offsetXChange - will be added to the Font.GlyphRegion.offsetX of each added glyph
  
  offsetYChange - will be added to the Font.GlyphRegion.offsetY of each added glyph
  
  xAdvanceChange - will be added to the Font.xAdvance(com.github.tommyettinger.textra.Font, float, long) of each added glyph
  
  Returns:
  
  changing, after the icon atlas has been added
- getGameIconsFont
  
  public static Font getGameIconsFont(float width, float height)
  Gets a typically-square Font that is meant to be used in a FontFamily, allowing switching to a Font with the many game-icons.net icons. The base Font this uses is getAStarry(), because it is perfectly square by default, and this needs all of AStarry's assets. It also needs the assets for addGameIcons(Font) to be present, since those will be available with this Font. The name this will use in a FontFamily is "Icons". You can specify the width and height you want for the icons; typically they are the same, because the icons here are square, and you probably want the height to match the line height for your main font. It isn't expected that many users would want to use the non-icon glyphs in the font. The reason this is needed is that you can't fit both the emoji from addEmoji(Font) and the icons from addGameIcons(Font) in one Font, but you can swap between two different Fonts in a FontFamily, one with emoji and one with icons.
  Preview: Image link (uses the font getNowAlt() and [%?blacken] mode)
  Needs files:
  
  AStarry-standard.fnt
  
  AStarry-standard.png
  
  AStarry-License.txt
  
  Game-Icons.atlas
  
  Game-Icons.png
  
  Game-Icons-License.txt
  Parameters:
  
  width - the width of a single glyph in the returned Font; usually matches the line-height of other text
  
  height - the height of a single glyph in the returned Font; usually matches the line-height of other text
  
  Returns:
  
  a preconfigured Font using getAStarry() and addGameIcons(Font), with name "Icons"
- pause
  
  public void pause()
  
  Specified by:
  
  pause in interface com.badlogic.gdx.LifecycleListener
- resume
  
  public void resume()
  
  Specified by:
  
  resume in interface com.badlogic.gdx.LifecycleListener
- getAll
  
  public static Font[] getAll()
  
  Returns a new array of Font instances, calling each getXyz() method in this class that returns any Font. This will only function at all if all the assets (for every known Font) are present and load-able. You should store the result of this method, rather than calling it often, because each call copies many Fonts.
  
  Returns:
  
  a new array containing all Font instances this knows
- getAllStandard
  
  public static Font[] getAllStandard()
  
  Returns a new array of Font instances, calling each getXyz() method in this class that returns any non-distance-field Font. This will only function at all if all the assets (for every known standard Font) are present and load-able. You should store the result of this method, rather than calling it often, because each call copies many Fonts.
  
  Returns:
  
  a new array containing all non-distance-field Font instances this knows
- getStandardFamily
  
  public static Font getStandardFamily()
  Returns a Font (getGentium()) with a FontFamily configured so that all non-distance-field Fonts can be used with syntax like [@Sans]. The names this supports can be accessed with code using getStandardFamily().family.fontAliases.keys(). These names so far are:
  
  Serif, which is getGentium(),
  
  Sans, which is getOpenSans(),
  
  Mono, which is getInconsolata(),
  
  Condensed, which is getRobotoCondensed(),
  
  Humanist, which is getYanoneKaffeesatz(),
  
  Retro, which is getIBM8x16(),
  
  Slab, which is getIosevkaSlab(),
  
  Handwriting, which is getCaveat(),
  
  Canada, which is getCanada(),
  
  Cozette, which is getCozette(),
  
  Iosevka, which is getIosevka(),
  
  Medieval, which is getKingthingsFoundation(),
  
  Future, which is getOxanium(),
  
  Console, which is getAStarry(), and
  
  Code, which is getCascadiaMono().
  
  Geometric, which is getNowAlt().
  
  You can also always use the full name of one of these fonts, which can be obtained using Font.getName(). Serif, which is getGentium(), will always be the default font used after a reset. For backwards compatibility, Bitter is an alias for getGentium() (not getBitter()), because Bitter and Gentium look very similar and because a slot was needed for Handwriting, which seemed useful in more situations.
  This will only function at all if all the assets (for every known standard Font) are present and load-able. You should store the result of this method, rather than calling it often, because each call copies many Fonts.
  Returns:
  
  a Font that can switch between 16 different Fonts in its FontFamily, to any of several Fonts this knows
- getAllSDF
  
  public static Font[] getAllSDF()
  
  Returns a new array of Font instances, calling each getXyz() method in this class that returns any SDF Font. This will only function at all if all the assets (for every known SDF Font) are present and load-able. You should store the result of this method, rather than calling it often, because each call copies 5 Fonts.
  
  Returns:
  
  a new array containing all SDF Font instances this knows
- getAllMSDF
  
  public static Font[] getAllMSDF()
  
  Returns a new array of Font instances, calling each getXyz() method in this class that returns any MSDF Font. This will only function at all if all the assets (for every known MSDF Font) are present and load-able. You should store the result of this method, rather than calling it often, because each call copies 9 Fonts.
  
  Returns:
  
  a new array containing all MSDF Font instances this knows
- dispose
  
  public void dispose()
  
  Specified by:
  
  dispose in interface com.badlogic.gdx.LifecycleListener

Class KnownFonts

Method Summary

Methods inherited from class java.lang.Object

Method Details

setAssetPrefix

getAStarry

getAStarryMSDF

getBitter

getCanada

getCascadiaMono

getCascadiaMonoMSDF

getCaveat

getCozette

getDejaVuSansMono

getGentium

getGentiumMSDF

getGentiumSDF

getGentiumUnItalic

getGoNotoUniversal

getGoNotoUniversalSDF

getHanazono

getIBM8x16

getInconsolata

getInconsolataMSDF

getIosevka

getIosevkaMSDF

getIosevkaSDF

getIosevkaSlab

getIosevkaSlabMSDF

getIosevkaSlabSDF

getKingthingsFoundation

getKingthingsPetrock

getLanaPixel

getLibertinusSerif

getNowAlt

getOpenSans

getOxanium

getQuanPixel

getRobotoCondensed

getTangerine

getTangerineSDF

getYanoneKaffeesatz

getYanoneKaffeesatzMSDF

getYataghanMSDF

addEmoji

addEmoji

addEmoji

addGameIcons

addGameIcons

addGameIcons

getGameIconsFont

pause

resume

getAll

getAllStandard

getStandardFamily

getAllSDF

getAllMSDF

dispose