FontFile

public FontFile();

Creates an empty resource without a loaded font. Load data, then configure options and assign it to a consumer.

public bool AllowSystemFallback { get; set; }

Allows missing characters to use system fonts; true by default. Results depend on the OS and installed fonts. Changing it emits Changed.

public TextServer.FontAntialiasing Antialiasing { get; set; }

Raster glyph antialiasing: None is one-bit, Gray grayscale, Lcd screen subpixels. Default Gray. Lcd suits horizontal unscaled 2D text; separate from SubpixelPositioning. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public byte[] Data { get; set; }

Dynamic-font bytes. Getter returns a managed copy; assign an edited copy back. Setter neither validates the format nor emits Changed. Not a complete BMFont package with images.

public bool DisableEmbeddedBitmaps { get; set; }

Disables embedded bitmap strikes in a dynamic font; true by default. Does not disable loading a separate BMFont. Color and bitmap-only fonts have format/backend limitations. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public int FixedSize { get; set; }

Fixed rasterization size; 0 disables a forced size. Not the Control text size. A change updates caches and emits Changed; loading resets it.

public TextServer.FixedSizeScaleMode FixedSizeScaleMode { get; set; }

Scaling with positive FixedSize: Disable does not scale, IntegerOnly uses an integer multiple, Enabled permits fractional scaling. Default Disable. For pixel bitmap fonts choose IntegerOnly and check the actual UI scale. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public string FontName { get; set; }

Family-name metadata in the first cache. Changing it neither loads another file nor emits Changed itself.

public int FontStretch { get; set; }

First-cache stretch metadata, 50–200, normal 100. The Advanced backend clamps the range; not a Transform scale or guaranteed glyph stretching. Setter does not emit Changed.

public TextServer.FontStyle FontStyle { get; set; }

First-cache style metadata flags. Do not guarantee synthetic bold or italic shapes; setter does not emit Changed.

public int FontWeight { get; set; }

First-cache weight metadata: 100–999, regular 400, bold 700. The Advanced backend clamps this range. Does not replace the required face or emit Changed.

public bool ForceAutohinter { get; set; }

Prefers automatic hinting over embedded dynamic-font instructions; false by default. Does not replace Hinting or add hinting to MSDF. Compare small text at the target scale. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public bool GenerateMipmaps { get; set; }

Generates mip levels for font textures; false by default. Can help minified text but needs memory and suitable consumer filtering. Enabling it does not guarantee sharper text. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public TextServer.Hinting Hinting { get; set; }

Fits a dynamic raster font to the pixel grid: None, Light or Normal; default Light. Normal can alter metrics along both axes, including monospace character widths. MSDF does not support hinting. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public bool KeepRoundingRemainders { get; set; }

Carries rounding remainders during pixel alignment to reduce accumulated spacing error; true by default. With subpixel positioning the corresponding horizontal-advance rounding is bypassed. Does not enable kerning. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public bool ModulateColorGlyphs { get; set; }

Applies RGB modulation to color glyphs too; false by default. When false, color glyphs retain their own RGB while draw opacity still applies. Does not add missing color characters. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public int MsdfPixelRange { get; set; }

MSDF distance range around the contour. A new FontFile uses 16; after LoadDynamicFont it is 14. For outlines use at least twice the largest outline width. Applies with MSDF enabled; a larger value alone does not increase precision. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public int MsdfSize { get; set; }

MSDF generation source size rather than the Control text size. A new FontFile uses 48; after LoadDynamicFont it is 128. Increase only for visible precision problems: generation and memory costs grow. Requires MSDF enabled. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public bool MultichannelSignedDistanceField { get; set; }

Uses a multichannel distance field for scalable glyphs from vector data; false by default. Configure MsdfSize and MsdfPixelRange after loading. Hinting is unavailable, small text may look worse, and overlapping contours need checking. Not a guarantee of cost-free scaling or quality with every file. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public Reckfell.Collections.Dictionary OpentypeFeatureOverrides { get; set; }

Shared OpenType feature settings: a tag key such as liga or kern and an integer value. 0 disables, positive values enable or select an alternative; negative values are skipped during shaping. Separate from variable-font axes. Dictionary storage is shared: use Duplicate for an independent snapshot. Neither the setter nor Dictionary edits emit Changed; do not rely on automatic reflow of already prepared text. Configure before use and inspect GetSupportedFeatureList for font support. File loading retains settings.

public float Oversampling { get; set; }

Dynamic-font rasterization factor: a positive value overrides the viewport setting; 0 leaves it in control. An explicit positive draw-method argument takes precedence. MSDF and positive FixedSize bypass oversampling. Not a text scale; account for memory and generation time. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public string StyleName { get; set; }

Style-name metadata in the first cache, for example Regular. Does not automatically select another font file or emit Changed.

public TextServer.SubpixelPositioning SubpixelPositioning { get; set; }

Horizontal glyph-position precision: Disabled, Auto, OneHalf or OneQuarter. A new FontFile uses Auto; after LoadDynamicFont it uses Disabled. Additional positions can require more cached glyph variants. Separate from Lcd antialiasing. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void ClearCache();

Clears caches and emits Changed while retaining Data and resource options. Does not unload all font bytes.

public void ClearGlyphs(int cacheIndex, Vector2I size);

Deletes glyph records for the chosen size/outline while retaining pages and manual kerning. Dynamic glyphs may be recreated on demand; restore manually supplied bitmap records yourself. Emits no Changed.

public void ClearKerningMap(int cacheIndex, int size);

Clears the size’s manual pair map without disabling source-font kerning. GetKerning need not return zero afterward. Emits no Changed.

public void ClearSizeCache(int cacheIndex);

Deletes all size caches of the selected RID, including glyphs, pages and manual metrics. Retains source Data and the FontFile slot itself. Emits no Changed. Rebuild data for a manual bitmap cache.

public void ClearTextures(int cacheIndex, Vector2I size);

Clears pages while retaining glyph records and page indices. A later query may detect an invalid atlas and attempt rerasterization; insufficient for a manual bitmap cache. Rebuild the whole size or use a new FontFile. Emits no Changed.

public TextServer.FontAntialiasing GetAntialiasing();

Reads Antialiasing without evaluating rendered quality. Raster glyph antialiasing: None is one-bit, Gray grayscale, Lcd screen subpixels. Default Gray. Lcd suits horizontal unscaled 2D text; separate from SubpixelPositioning.

public float GetCacheAscent(int cacheIndex, int size);

Reads the distance above the baseline. Querying can create a size cache; for MSDF/scalable FixedSize the backend rescales the result to the requested size.

public int GetCacheCount();

Returns the number of internal font RID slots. Not a glyph, file or validated-face count; metadata access can create a slot lazily.

public float GetCacheDescent(int cacheIndex, int size);

Reads the distance below the baseline. Querying can create a size cache; for MSDF/scalable FixedSize the backend rescales the result to the requested size.

public float GetCacheScale(int cacheIndex, int size);

Reads the color bitmap-cache scale. Querying can create a size cache; for MSDF/scalable FixedSize the backend rescales the result to the requested size.

public float GetCacheUnderlinePosition(int cacheIndex, int size);

Reads the underline position relative to the baseline. Querying can create a size cache; for MSDF/scalable FixedSize the backend rescales the result to the requested size.

public float GetCacheUnderlineThickness(int cacheIndex, int size);

Reads the underline thickness. Querying can create a size cache; for MSDF/scalable FixedSize the backend rescales the result to the requested size.

public long GetCharFromGlyphIndex(int size, int glyphIndex);

Looks up a Unicode code point from a first-cache glyph index. For a dynamic font this is a cmap lookup rather than inverse string shaping: several characters can share one glyph. Not suitable for restoring ligatures, UTF-16 positions or arbitrary bitmap caches.

public byte[] GetData();

Returns a managed copy of source bytes. Editing the result does not modify FontFile; use SetData. BMFont page images are not packaged into this result.

public bool GetDisableEmbeddedBitmaps();

Reads DisableEmbeddedBitmaps without evaluating rendered quality. Disables embedded bitmap strikes in a dynamic font; true by default. Does not disable loading a separate BMFont. Color and bitmap-only fonts have format/backend limitations.

public float GetEmbolden(int cacheIndex);

Reads synthetic embolden strength of the selected cache; default 0. Not the weight of a genuine face.

public float GetExtraBaselineOffset(int cacheIndex);

Reads extra baseline offset as a fraction of font height; default 0. Not pixels.

public long GetExtraSpacing(int cacheIndex, TextServer.SpacingType spacing);

Reads additional spacing of the chosen type in pixels rather than a font-size factor. Default 0.

public long GetFaceIndex(int cacheIndex);

Reads the stored collection face index, default 0. The getter alone does not establish that the file contains that face.

public int GetFixedSize();

Reads FixedSize without measuring text or glyph height.

public TextServer.FixedSizeScaleMode GetFixedSizeScaleMode();

Reads FixedSizeScaleMode without evaluating rendered quality. Scaling with positive FixedSize: Disable does not scale, IntegerOnly uses an integer multiple, Enabled permits fractional scaling. Default Disable. For pixel bitmap fonts choose IntegerOnly and check the actual UI scale.

public bool GetGenerateMipmaps();

Reads GenerateMipmaps without evaluating rendered quality. Generates mip levels for font textures; false by default. Can help minified text but needs memory and suitable consumer filtering. Enabling it does not guarantee sharper text.

public Vector2 GetGlyphAdvance(int cacheIndex, int size, int glyph);

Reads pen advance, creating a dynamic glyph if needed. MSDF/FixedSize, embolden and rounding can affect the result. Not visible pixel bounds or the size of a complete shaped string.

public int GetGlyphIndex(int size, long @char, long variationSelector);

Maps a Unicode code point and optional variation selector to a first-cache glyph index. Not a UTF-16 string index or full shaping: TextServer handles ligatures/contextual forms. For a manual bitmap font the backend can use the character code itself as a key.

public int[] GetGlyphList(int cacheIndex, Vector2I size);

Returns keys of existing glyph records in the chosen cache rather than every character in the font file. Keys may include subpixel/LCD cache variants; order is unspecified. The managed result is a copy.

public Vector2 GetGlyphOffset(int cacheIndex, Vector2I size, int glyph);

Reads the local glyph offset with supported MSDF/FixedSize scaling. Not an Entity or Control position. Querying can prepare a dynamic record.

public Vector2 GetGlyphSize(int cacheIndex, Vector2I size, int glyph);

Returns the drawn rectangle size, possibly zero for a nonvisual character. MSDF/FixedSize scaling can affect it. Not character advance.

public int GetGlyphTextureIdx(int cacheIndex, Vector2I size, int glyph);

Reads the page index; the Advanced backend returns -1 without a drawable texture/prepared glyph. Check against GetTextureCount. After RemoveTexture even an in-range index may refer to a different page.

public Rect2 GetGlyphUVRect(int cacheIndex, Vector2I size, int glyph);

Reads the source rectangle in atlas-page pixels. Neither screen coordinates nor normalized UVs. Querying can create a dynamic glyph.

public TextServer.Hinting GetHinting();

Reads Hinting without evaluating rendered quality. Fits a dynamic raster font to the pixel grid: None, Light or Normal; default Light. Normal can alter metrics along both axes, including monospace character widths. MSDF does not support hinting.

public bool GetKeepRoundingRemainders();

Reads KeepRoundingRemainders without evaluating rendered quality. Carries rounding remainders during pixel alignment to reduce accumulated spacing error; true by default. With subpixel positioning the corresponding horizontal-advance rounding is bypassed. Does not enable kerning.

public Vector2 GetKerning(int cacheIndex, int size, Vector2I glyphPair);

Reads a manual pair adjustment; without one the backend may query source-font data. Not the result of full string shaping or a list of OpenType rules.

public Reckfell.Collections.Array<Vector2I> GetKerningList(int cacheIndex, int size);

Returns glyph pairs in this size’s manual kerning map rather than every pair in the source OpenType file. Order is unspecified. Typed Array is not IDisposable.

public bool GetLanguageSupportOverride(string language);

Reads only the explicit language entry. false means either a missing entry or an explicit denial; distinguish them with GetLanguageSupportOverrides. Does not resolve the wildcard entry here. Not a character-coverage check.

public string[] GetLanguageSupportOverrides();

Returns explicit language override keys, including false entries and the wildcard. Order is unspecified; not a list of every language the font can display.

public int GetMsdfPixelRange();

Reads MsdfPixelRange without evaluating rendered quality. MSDF distance range around the contour. A new FontFile uses 16; after LoadDynamicFont it is 14. For outlines use at least twice the largest outline width. Applies with MSDF enabled; a larger value alone does not increase precision.

public int GetMsdfSize();

Reads MsdfSize without evaluating rendered quality. MSDF generation source size rather than the Control text size. A new FontFile uses 48; after LoadDynamicFont it is 128. Increase only for visible precision problems: generation and memory costs grow. Requires MSDF enabled.

public Reckfell.Collections.Dictionary GetOpentypeFeatureOverrides();

Returns a Dictionary sharing the resource’s OpenType feature table. Editing it changes resource data without Changed; Duplicate provides a separate table. Dispose the managed wrapper after reading. An entry does not establish support by the file.

public float GetOversampling();

Reads Oversampling without evaluating rendered quality. Dynamic-font rasterization factor: a positive value overrides the viewport setting; 0 leaves it in control. An explicit positive draw-method argument takes precedence. MSDF and positive FixedSize bypass oversampling. Not a text scale; account for memory and generation time.

public bool GetScriptSupportOverride(string script);

Reads an explicit writing-script entry. Also returns false without an entry; check presence through GetScriptSupportOverrides. Does not resolve the wildcard or inspect glyphs, and is unrelated to C# scripts.

public string[] GetScriptSupportOverrides();

Returns writing-script override keys, including false entries and the wildcard, in unspecified order. Not the file’s automatically detected script list.

public Reckfell.Collections.Array<Vector2I> GetSizeCacheList(int cacheIndex);

Lists ordinary size caches of the selected font RID as Vector2I(font size, outline thickness). The Advanced backend excludes viewport-oversampling entries; not a complete memory report. Querying can lazily create a RID and base size cache.

public TextServer.SubpixelPositioning GetSubpixelPositioning();

Reads SubpixelPositioning without evaluating rendered quality. Horizontal glyph-position precision: Disabled, Auto, OneHalf or OneQuarter. A new FontFile uses Auto; after LoadDynamicFont it uses Disabled. Additional positions can require more cached glyph variants. Separate from Lcd antialiasing.

public int GetTextureCount(int cacheIndex, Vector2I size);

Atlas page count for a size/outline, rather than glyph count. Querying can create the size cache. Does not establish that every glyph points to the correct page.

public Image GetTextureImage(int cacheIndex, Vector2I size, int textureIndex);

Returns the page’s shared Image rather than a pixel copy or screenshot. Editing Image can affect other consumers; copy it for independent editing. Image edits alone do not guarantee atlas-texture recreation.

public int[] GetTextureOffsets(int cacheIndex, Vector2I size, int textureIndex);

Reads page shelf data in x, y, width, height groups. C# returns an int[] copy; apply edits through SetTextureOffsets. Not glyph rectangles.

public Transform2D GetTransform(int cacheIndex);

Reads the outline transform matrix; default Identity. Not the Control global transform.

public Reckfell.Collections.Dictionary GetVariationCoordinates(int cacheIndex);

Returns the selected cache’s shared axis-coordinate table. Unlike FontVariation, this getter does not create an independent copy. Editing an alias bypasses the setter/cache reset; Duplicate it and call SetVariationCoordinates to apply changes.

public bool IsAllowSystemFallback();

Reads the system fallback permission rather than font or character availability.

public bool IsForceAutohinter();

Reads ForceAutohinter without evaluating rendered quality. Prefers automatic hinting over embedded dynamic-font instructions; false by default. Does not replace Hinting or add hinting to MSDF. Compare small text at the target scale.

public bool IsModulateColorGlyphs();

Reads ModulateColorGlyphs without evaluating rendered quality. Applies RGB modulation to color glyphs too; false by default. When false, color glyphs retain their own RGB while draw opacity still applies. Does not add missing color characters.

public bool IsMultichannelSignedDistanceField();

Reads MultichannelSignedDistanceField without evaluating rendered quality. Uses a multichannel distance field for scalable glyphs from vector data; false by default. Configure MsdfSize and MsdfPixelRange after loading. Hinting is unavailable, small text may look worse, and overlapping contours need checking. Not a guarantee of cost-free scaling or quality with every file.

public Error LoadBitmapFont(string path);

Loads text BMFont or binary BMFont version 3 with page images relative to its directory. Resets previous state; failure may leave partial changes. Check Error and diagnostics.

public Error LoadDynamicFont(string path);

Resets state and reads a file into Data. In 1.0.0 Error.Ok does not establish successful reading or decoding: check the file, data, required glyphs and rendering. Configure options after loading; there is no rollback.

public void RemoveCache(int cacheIndex);

Removes a slot, frees its RID, shifts subsequent indices and emits Changed. Recheck retained indices after removal.

public void RemoveGlyph(int cacheIndex, Vector2I size, int glyph);

Deletes one cache record while retaining pages, kerning and font data. Does not remove a character from the source file; a dynamic record can reappear on demand. Emits no Changed.

public void RemoveKerning(int cacheIndex, int size, Vector2I glyphPair);

Removes an ordered pair’s manual adjustment and restores normal backend/file behavior. Does not remove glyphs; a missing entry is a no-op. Emits no Changed.

public void RemoveLanguageSupportOverride(string language);

Removes an exact key if present and propagates removal to existing caches. Restores normal selection/the wildcard rather than explicitly denying support. A missing key is a no-op; does not emit Changed.

public void RemoveScriptSupportOverride(string script);

Removes an explicit writing-script decision and restores selection from the file/the wildcard. Does not remove glyphs. A missing key is ignored; does not emit Changed.

public void RemoveSizeCache(int cacheIndex, Vector2I size);

Deletes one size/outline cache while retaining the RID and source data. Use a key from GetSizeCacheList; MSDF, FixedSize and oversampling affect effective keys. A missing entry is a no-op. Emits no Changed.

public void RemoveTexture(int cacheIndex, Vector2I size, int textureIndex);

Removes a page and shifts subsequent pages. In 1.0.0 glyph indices are not remapped: an old in-range index can point to the wrong image, while an out-of-range index can trigger diagnostics/rerasterization. Rebuild all dependent records when removing a page from an active bitmap atlas. Emits no Changed.

public void RenderGlyph(int cacheIndex, Vector2I size, int index);

Prepares a dynamic glyph and required variants in the cache. Takes a glyph index rather than a Unicode code point. Does not draw text on screen or fill a missing manual bitmap atlas. Configure quality before preparation.

public void RenderRange(int cacheIndex, Vector2I size, long start, long end);

Prepares dynamic glyphs for a Unicode range including both endpoints. Not a glyph-index or UTF-16 range. Limit it to needed characters: broad ranges consume time and memory. Neither replaces shaping nor draws text.

public void SetAllowSystemFallback(bool allowSystemFallback);

Allows missing characters to use system fonts; true by default. Results depend on the OS and installed fonts. Changing it emits Changed.

public void SetAntialiasing(TextServer.FontAntialiasing antialiasing);

Raster glyph antialiasing: None is one-bit, Gray grayscale, Lcd screen subpixels. Default Gray. Lcd suits horizontal unscaled 2D text; separate from SubpixelPositioning. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetCacheAscent(int cacheIndex, int size, float ascent);

Sets the size cache’s distance above the baseline. Manual metadata rather than a change to source outlines or Control size. Emits no Changed.

public void SetCacheDescent(int cacheIndex, int size, float descent);

Sets the size cache’s distance below the baseline. Manual metadata rather than a change to source outlines or Control size. Emits no Changed.

public void SetCacheScale(int cacheIndex, int size, float scale);

Sets the size cache’s color bitmap-cache scale. Manual metadata rather than a change to source outlines or Control size. Emits no Changed.

public void SetCacheUnderlinePosition(int cacheIndex, int size, float underlinePosition);

Sets the size cache’s underline position relative to the baseline. Manual metadata rather than a change to source outlines or Control size. Emits no Changed.

public void SetCacheUnderlineThickness(int cacheIndex, int size, float underlineThickness);

Sets the size cache’s underline thickness. Manual metadata rather than a change to source outlines or Control size. Emits no Changed.

public void SetData(byte[] data);

Replaces font bytes and passes them to existing caches. Does not fully reset state or emit Changed; empty or malformed bytes do not become a validated font.

public void SetData(ReadOnlySpan<byte> data);

Replaces font bytes and passes them to existing caches. Does not fully reset state or emit Changed; empty or malformed bytes do not become a validated font.

public void SetDisableEmbeddedBitmaps(bool disableEmbeddedBitmaps);

Disables embedded bitmap strikes in a dynamic font; true by default. Does not disable loading a separate BMFont. Color and bitmap-only fonts have format/backend limitations. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetEmbolden(int cacheIndex, float strength);

Sets synthetic outline emboldening: 0 unchanged, positive thickens, negative thins. Not a replacement for a genuine face or weight axis. Changing it can clear backend caches. Direct cache edits do not emit Changed; configure before using the resource.

public void SetExtraBaselineOffset(int cacheIndex, float baselineOffset);

Sets extra baseline offset as a fraction of font height rather than pixels. Separate from SetGlyphOffset or the Control Transform. Direct cache edits do not emit Changed; configure before using the resource.

public void SetExtraSpacing(int cacheIndex, TextServer.SpacingType spacing, long value);

Sets extra pixels for Glyph, Space, Top or Bottom. Not a pair-kerning map or font size. Direct cache edits do not emit Changed; configure before using the resource.

public void SetFaceIndex(int cacheIndex, long faceIndex);

Selects a face inside a font collection; index must be nonnegative, below 32767 and below the actual face count. Not a variation/cache index. A numerically accepted value does not establish file decoding. Direct cache edits do not emit Changed; configure before using the resource.

public void SetFixedSize(int fixedSize);

Fixed rasterization size; 0 disables a forced size. Not the Control text size. A change updates caches and emits Changed; loading resets it.

public void SetFixedSizeScaleMode(TextServer.FixedSizeScaleMode fixedSizeScaleMode);

Scaling with positive FixedSize: Disable does not scale, IntegerOnly uses an integer multiple, Enabled permits fractional scaling. Default Disable. For pixel bitmap fonts choose IntegerOnly and check the actual UI scale. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetFontName(string name);

Family-name metadata in the first cache. Changing it neither loads another file nor emits Changed itself.

public void SetFontStretch(int stretch);

First-cache stretch metadata, 50–200, normal 100. The Advanced backend clamps the range; not a Transform scale or guaranteed glyph stretching. Setter does not emit Changed.

public void SetFontStyle(TextServer.FontStyle style);

First-cache style metadata flags. Do not guarantee synthetic bold or italic shapes; setter does not emit Changed.

public void SetFontStyleName(string name);

Style-name metadata in the first cache, for example Regular. Does not automatically select another font file or emit Changed.

public void SetFontWeight(int weight);

First-cache weight metadata: 100–999, regular 400, bold 700. The Advanced backend clamps this range. Does not replace the required face or emit Changed.

public void SetForceAutohinter(bool forceAutohinter);

Prefers automatic hinting over embedded dynamic-font instructions; false by default. Does not replace Hinting or add hinting to MSDF. Compare small text at the target scale. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetGenerateMipmaps(bool generateMipmaps);

Generates mip levels for font textures; false by default. Can help minified text but needs memory and suitable consumer filtering. Enabling it does not guarantee sharper text. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetGlyphAdvance(int cacheIndex, int size, int glyph, Vector2 advance);

Sets pen advance after a glyph in the unoutlined cache. Not the visible rectangle width: a space can advance without an image. Creates/updates a record rather than its page or outline. Emits no Changed.

public void SetGlyphOffset(int cacheIndex, Vector2I size, int glyph, Vector2 offset);

Sets the glyph rectangle’s local offset from its draw position. Does not change page UVs or advance. Keep all bitmap-atlas record fields consistent. Emits no Changed.

public void SetGlyphSize(int cacheIndex, Vector2I size, int glyph, Vector2 glSize);

Sets the drawn glyph rectangle size rather than font size or advance. Does not create an image by itself. Emits no Changed.

public void SetGlyphTextureIdx(int cacheIndex, Vector2I size, int glyph, int textureIdx);

Sets a glyph record’s page index without assigning Image or validating the complete atlas. Requires the correct existing page; -1 denotes no texture. Emits no Changed.

public void SetGlyphUVRect(int cacheIndex, Vector2I size, int glyph, Rect2 uVRect);

Sets a rectangle in atlas-image pixels rather than normalized 0–1 UVs. Must match the GlyphTextureIdx page and its dimensions. Does not set font size. Emits no Changed.

public void SetHinting(TextServer.Hinting hinting);

Fits a dynamic raster font to the pixel grid: None, Light or Normal; default Light. Normal can alter metrics along both axes, including monospace character widths. MSDF does not support hinting. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetKeepRoundingRemainders(bool keepRoundingRemainders);

Carries rounding remainders during pixel alignment to reduce accumulated spacing error; true by default. With subpixel positioning the corresponding horizontal-advance rounding is bypassed. Does not enable kerning. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetKerning(int cacheIndex, int size, Vector2I glyphPair, Vector2 kerning);

Sets a manual adjustment for an ordered glyph-index pair. Does not create glyphs or enable the OpenType kern feature. MSDF/FixedSize affect effective values. Emits no Changed.

public void SetLanguageSupportOverride(string language, bool supported);

Sets an explicit decision for the exact language key and updates existing font RIDs. The wildcard supplies the result without an exact entry. Adds neither glyphs nor shaping and emits no Changed. Configure before using the resource. File loading retains these entries.

public void SetModulateColorGlyphs(bool modulate);

Applies RGB modulation to color glyphs too; false by default. When false, color glyphs retain their own RGB while draw opacity still applies. Does not add missing color characters. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetMsdfPixelRange(int msdfPixelRange);

MSDF distance range around the contour. A new FontFile uses 16; after LoadDynamicFont it is 14. For outlines use at least twice the largest outline width. Applies with MSDF enabled; a larger value alone does not increase precision. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetMsdfSize(int msdfSize);

MSDF generation source size rather than the Control text size. A new FontFile uses 48; after LoadDynamicFont it is 128. Increase only for visible precision problems: generation and memory costs grow. Requires MSDF enabled. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetMultichannelSignedDistanceField(bool msdf);

Uses a multichannel distance field for scalable glyphs from vector data; false by default. Configure MsdfSize and MsdfPixelRange after loading. Hinting is unavailable, small text may look worse, and overlapping contours need checking. Not a guarantee of cost-free scaling or quality with every file. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetOpentypeFeatureOverrides(Reckfell.Collections.Dictionary overrides);

Shared OpenType feature settings: a tag key such as liga or kern and an integer value. 0 disables, positive values enable or select an alternative; negative values are skipped during shaping. Separate from variable-font axes. Dictionary storage is shared: use Duplicate for an independent snapshot. Neither the setter nor Dictionary edits emit Changed; do not rely on automatic reflow of already prepared text. Configure before use and inspect GetSupportedFeatureList for font support. File loading retains settings.

public void SetOversampling(float oversampling);

Dynamic-font rasterization factor: a positive value overrides the viewport setting; 0 leaves it in control. An explicit positive draw-method argument takes precedence. MSDF and positive FixedSize bypass oversampling. Not a text scale; account for memory and generation time. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetScriptSupportOverride(string script, bool supported);

Sets a decision for an exact writing-script code such as Latn or Cyrl; the wildcard applies without an exact key. Does not change character shapes or add missing glyphs. Updates existing font RIDs without Changed; file loading retains entries.

public void SetSubpixelPositioning(TextServer.SubpixelPositioning subpixelPositioning);

Horizontal glyph-position precision: Disabled, Auto, OneHalf or OneQuarter. A new FontFile uses Auto; after LoadDynamicFont it uses Disabled. Additional positions can require more cached glyph variants. Separate from Lcd antialiasing. Changing the value emits Changed; assigning the same value does not. Loading resets this option.

public void SetTextureImage(int cacheIndex, Vector2I size, int textureIndex, Image image);

Assigns a nonnull Image to an atlas page and creates its texture; a higher index grows the page table. Image is retained as a shared resource. Does not set glyph rectangles/metrics or emit Changed. Build a consistent cache before use.

public void SetTextureOffsets(int cacheIndex, Vector2I size, int textureIndex, int[] offset);

Replaces internal atlas shelf-packing data: groups of four ints, x, y, width, height. Length must be divisible by 4. Not an individual glyph offset or UV array. C# copies input; array and span overloads are equivalent. Emits no Changed.

public void SetTextureOffsets(int cacheIndex, Vector2I size, int textureIndex, ReadOnlySpan<int> offset);

Replaces internal atlas shelf-packing data: groups of four ints, x, y, width, height. Length must be divisible by 4. Not an individual glyph offset or UV array. C# copies input; array and span overloads are equivalent. Emits no Changed.

public void SetTransform(int cacheIndex, Transform2D transform);

Sets an outline transform such as slant or rotation. A synthetic glyph change rather than moving UI; do not use Origin as the text position. Direct cache edits do not emit Changed; configure before using the resource.

public void SetVariationCoordinates(int cacheIndex, Reckfell.Collections.Dictionary variationCoordinates);

Copies a flat axis → number table into the chosen cache; obtain axes/ranges from GetSupportedVariationList. Prefer numeric tags from TextServer.NameToTag. These are variable-font axes rather than liga/kern features. The backend clears its cache when the table changes. Direct cache edits do not emit Changed; configure before using the resource.