korge-core/korlibs.image.font

Package-level declarations

Types

abstract class BaseTtfFont(s: FastByteArrayInputStream, extName: String? = null, onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true) : VectorFont, Extra

BitmapFont

interface BitmapFont : Font

CharacterSet

class CharacterSet(val codePoints: IntArray)

DefaultFontRegistry

open class DefaultFontRegistry(val coroutineContext: CoroutineContext) : FontRegistry

FallbackNativeSystemFontProvider

open class FallbackNativeSystemFontProvider(val ttf: TtfFont) : TtfNativeSystemFontProvider

FolderBasedNativeSystemFontProvider

open class FolderBasedNativeSystemFontProvider(val context: CoroutineContext, val folders: List<String> = (linuxFolders + windowsFolders + macosFolders + androidFolders + iosFolders).distinct(), val fontCacheFile: VfsFile = standardVfs.userSharedCacheFile("korimFontCache")) : TtfNativeSystemFontProvider

Font

interface Font : Resourceable<Font> , Extra

FontMetrics

data class FontMetrics(var size: Double = 0.0, var top: Double = 0.0, var ascent: Double = 0.0, var baseline: Double = 0.0, var descent: Double = 0.0, var bottom: Double = 0.0, var lineGap: Double = 0.0, var maxWidth: Double = 0.0, var unitsPerEm: Double = 0.0)

FontRegistry

interface FontRegistry

GlyphMetrics

data class GlyphMetrics(var size: Double = 0.0, var existing: Boolean = false, var codePoint: Int = 0, var bounds: Rectangle = Rectangle(), var xadvance: Double = 0.0)

GlyphPath

data class GlyphPath(var path: VectorPath = VectorPath(), var colorShape: Shape? = null, var bitmap: Bitmap? = null, var bitmapOffset: Point = Point(0, 0), var bitmapScale: Scale = Scale(1, 1), var transform: Matrix = Matrix(), var scale: Double = 1.0) : Drawable

LazyBitmapFont

class LazyBitmapFont(val font: VectorFont, val fontSize: Double, val distanceField: String? = null) : BitmapFont, Extra

MultiplePlacedGlyphMetrics

class MultiplePlacedGlyphMetrics

NativeSystemFontProvider

open class NativeSystemFontProvider

PlacedGlyphMetrics

data class PlacedGlyphMetrics(val codePoint: Int, val pos: Point, val metrics: GlyphMetrics, val fontMetrics: FontMetrics, val transform: Matrix, val index: Int, val nline: Int)

SystemFont

class SystemFont(val name: String, val coroutineContext: CoroutineContext) : VectorFont, Resourceable<Font> , Extra

TextMetrics

data class TextMetrics(var bounds: Rectangle = Rectangle(), var lineBounds: List<Rectangle> = emptyList(), val fontMetrics: FontMetrics = FontMetrics(), var nlines: Int = 0)

TextMetricsResult

data class TextMetricsResult(var fmetrics: FontMetrics = FontMetrics(), var metrics: TextMetrics = TextMetrics(), var glyphs: List<PlacedGlyphMetrics> = emptyList(), var glyphsPerLine: List<List<PlacedGlyphMetrics>> = emptyList()) : BaseTextMetricsResult

TextToBitmapResult

data class TextToBitmapResult(val bmp: Bitmap, val fmetrics: FontMetrics, val metrics: TextMetrics, val glyphs: List<PlacedGlyphMetrics>, val glyphsPerLine: List<List<PlacedGlyphMetrics>>, val shape: Shape? = null) : BaseTextMetricsResult

TtfCIDFont

object TtfCIDFont

Compact Font Format font representation (also known as a PostScript Type 1, or CIDFont) https://docs.microsoft.com/en-us/typography/opentype/spec/cff

TtfFont

class TtfFont(d: ByteArray, extName: String? = null, onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true) : BaseTtfFont

TtfNativeSystemFontProvider

abstract class TtfNativeSystemFontProvider : NativeSystemFontProvider

VectorFont

interface VectorFont : Font

VectorFontList

data class VectorFontList(val list: List<VectorFont>) : VectorFont, Extra

WoffFont

class WoffFont(d: ByteArray, extName: String? = null, onlyReadMetadata: Boolean = false) : BaseTtfFont

Properties

_nativeSystemFontProvider

var _nativeSystemFontProvider: NativeSystemFontProvider?

DefaultTtfFont

val DefaultTtfFont: TtfFont

DefaultTtfFontAsBitmap

val DefaultTtfFontAsBitmap: LazyBitmapFont

lazyBitmap

val Font.lazyBitmap: BitmapFont

Gets a BitmapFont from the font, that is going to be computed lazily as glyphs are required.

val VectorFont.lazyBitmap: LazyBitmapFont

Returns, creates and caches a LazyBitmapFont instance from the VectorFont that will generate and cache glyphs as required.

lazyBitmapSDF

val VectorFont.lazyBitmapSDF: LazyBitmapFont

Functions

asFallbackOf

fun VectorFont.asFallbackOf(first: VectorFont): VectorFontList

When getting glyphs, it first tries to resolve with first, then this this

drawText

fun Bitmap32.drawText(font: BitmapFont, str: String, pos: Point = Point.ZERO, color: RGBA = Colors.WHITE, size: Double = font.fontSize, alignment: TextAlignment = TextAlignment.TOP_LEFT): Bitmap32

fun <T> Font.drawText(ctx: Context2d?, size: Double, text: T, paint: Paint?, pos: Point = Point.ZERO, fill: Boolean = true, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.BASELINE_LEFT, outMetrics: TextMetricsResult? = null, fillStyle: Paint? = null, stroke: Stroke? = null, textRangeStart: Int = 0, textRangeEnd: Int = Int.MAX_VALUE, placed: TextRendererActions.(codePoint: Int, Point, size: Double, metrics: GlyphMetrics, fmetrics: FontMetrics, transform: Matrix) -> Unit? = null): TextMetricsResult?

getTextBounds

fun <T> Font.getTextBounds(size: Double, text: T, out: TextMetrics = TextMetrics(), renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.TOP_LEFT): TextMetrics

getTextBoundsWithGlyphs

fun <T> Font.getTextBoundsWithGlyphs(size: Double, text: T, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.BASELINE_LEFT): TextMetricsResult

nativeSystemFontProvider

suspend fun nativeSystemFontProvider(): NativeSystemFontProvider

fun nativeSystemFontProvider(coroutineContext: CoroutineContext): NativeSystemFontProvider

readBitmapFont

suspend fun VfsFile.readBitmapFont(props: ImageDecodingProps = ImageDecodingProps.DEFAULT, mipmaps: Boolean = true, atlas: MutableAtlasUnit? = null): BitmapFont

readFont

suspend fun VfsFile.readFont(preload: Boolean = false, props: ImageDecodingProps = ImageDecodingProps.DEFAULT, mipmaps: Boolean = true): Font

readTtfFont

suspend fun VfsFile.readTtfFont(onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true): TtfFont

readWoffFont

suspend fun VfsFile.readWoffFont(onlyReadMetadata: Boolean = false): WoffFont

suspend fun <T : Font> T.register(name: String = this.name): T

fun <T : Font> T.register(registry: DefaultFontRegistry, name: String = this.name): T

registerTemporarily

inline suspend fun <T> Font.registerTemporarily(name: String = this.name, block: () -> T): T

inline fun <T> Font.registerTemporarily(registry: DefaultFontRegistry, name: String = this.name, block: () -> T): T

renderGlyphToBitmap

fun Font.renderGlyphToBitmap(size: Double, codePoint: Int, paint: Paint = DefaultPaint, fill: Boolean = true, effect: BitmapEffect? = null, border: Int = 1, nativeRendering: Boolean = true, reader: WStringReader? = null): TextToBitmapResult

renderTextToBitmap

fun <T> Font.renderTextToBitmap(size: Double, text: T, paint: Paint = DefaultPaint, background: Paint = NonePaint, fill: Boolean = true, border: Int = 0, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, returnGlyphs: Boolean = true, nativeRendering: Boolean = true, drawBorder: Boolean = false): TextToBitmapResult

SystemFont

suspend fun SystemFont(name: String): SystemFont

SystemFontRegistry

suspend fun SystemFontRegistry(): DefaultFontRegistry

fun SystemFontRegistry(coroutineContext: CoroutineContext): DefaultFontRegistry

toBitmapFont

inline fun Font.toBitmapFont(fontSize: Number, chars: CharacterSet = CharacterSet.LATIN_ALL, fontName: String = this.name, paint: Paint = Colors.WHITE, mipmaps: Boolean = true, effect: BitmapEffect? = null): BitmapFont

toLazyBitmapFont

fun VectorFont.toLazyBitmapFont(fontSize: Double, distanceField: String? = null): LazyBitmapFont

withFallback

fun VectorFont.withFallback(vararg other: VectorFont?): VectorFontList

When getting glyphs, it first tries to resolve with this, then in order other

writeToFile

suspend fun BitmapFont.writeToFile(out: VfsFile, writeBitmap: Boolean = true)