mirror of
https://github.com/be5invis/Iosevka.git
synced 2026-10-28 08:28:01 +00:00
2245 lines
67 KiB
Plaintext
2245 lines
67 KiB
Plaintext
$$include '../meta/macros.ptl'
|
|
|
|
import [mix barmixL linreg clamp fallback] from '../support/utils'
|
|
import [designParameters] from '../meta/aesthetics'
|
|
|
|
export : define [apply] : begin
|
|
glyph-module-entry commonShapes overmarks letterBasic
|
|
|
|
###########################################################################################
|
|
# UNIFIED LETTERFORMS : GREEK ORIGINALS
|
|
###########################################################################################
|
|
sketch
|
|
include MarkSet.e
|
|
|
|
local middle : mix SB RIGHTSB 0.42
|
|
local fine : adviceBlackness 3.25
|
|
local k1 0.25
|
|
local k2 0.5
|
|
local k3 0.35
|
|
include : dispiro
|
|
widths.rhs fine
|
|
g4 (RIGHTSB - OX * 1.75) XH [heading DOWNWARD]
|
|
bezcontrols k1 k2 k3 1 6
|
|
g4.left.mid (middle + CORRECTION_OMIDS) O [widths 0 STROKE]
|
|
archv
|
|
flat.ai (SB + OX * 2) SMALLSMOOTHB
|
|
curl.ai (SB + OX * 2) (XH - SMALLSMOOTHA)
|
|
arcvh
|
|
g4.right.mid (middle - CORRECTION_OMIDS) XO [widths 0 STROKE]
|
|
bezcontrols (1 - k3) 0 (1 - k1) (1 - k2) 6
|
|
g4 (RIGHTSB - OX * 2) 0 [widths.heading 0 fine DOWNWARD]
|
|
|
|
set-anchor 'overlay' BASE (middle - OX) (XH * OVERLAYPOS)
|
|
|
|
save 'alpha' 0x3B1
|
|
save 'latinalpha' 0xAB64
|
|
|
|
define [GammaShape top] : glyph-construction
|
|
include : VBarLeft (SB * 1.5) 0 top
|
|
include : HBarTop (SB * 1.5 - O) (RIGHTSB - OX) top
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (SB * 1.5) top SIDEJUT
|
|
include : CenterBottomSerif (SB * 1.5 + HVCONTRAST * HALFSTROKE) 0 JUT
|
|
include : tagged 'serifRT' : DownwardRightSerif (RIGHTSB - OX) top VJUT
|
|
|
|
sketch # Gamma
|
|
include MarkSet.capital
|
|
include : GammaShape CAP
|
|
save 'Gamma' 0x393
|
|
save 'cyrGhe' 0x413
|
|
|
|
sketch # cyrghe.upright
|
|
include MarkSet.e
|
|
include : GammaShape XH
|
|
save 'cyrghe.upright'
|
|
|
|
sketch # cyrghe.SRB
|
|
include glyphs.dotlessi AS_BASE
|
|
include glyphs.macronAbove
|
|
save 'cyrghe.SRB'
|
|
|
|
italic-variant 'cyrghe' 0x433
|
|
|
|
define [CyrGeShape top] : glyph-construction
|
|
include : GammaShape top
|
|
eject-contour 'serifRT'
|
|
include : VBarRight (RIGHTSB - OX) top (top + ACCENT)
|
|
|
|
sketch # cyrGe
|
|
include MarkSet.capital
|
|
include : CyrGeShape CAP
|
|
|
|
save 'cyrGe' 0x490
|
|
|
|
sketch # cyrge
|
|
include MarkSet.e
|
|
include : CyrGeShape XH
|
|
|
|
save 'cyrge' 0x491
|
|
|
|
sketch # cyrGhayn
|
|
include glyphs.cyrGhe AS_BASE
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + STROKE) (RIGHTSB - STROKE) 0.55] (CAP * (1 - OVERLAYPOS))
|
|
|
|
save 'cyrGhayn' 0x492
|
|
|
|
sketch # cyrghayn.upright
|
|
include glyphs.'cyrghe.upright' AS_BASE
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + STROKE) (RIGHTSB - STROKE) 0.55] (XH * (1 - OVERLAYPOS))
|
|
|
|
save 'cyrghayn.upright'
|
|
|
|
sketch # cyrghayn.italic
|
|
include glyphs.'cyrghe.italic' AS_BASE
|
|
include : FlatSlashShape MIDDLE (XH / 2) (OVERLAYSTROKE / 2) (-0.2) 0.75
|
|
save 'cyrghayn.italic'
|
|
save 'voicedlaryngenalspirant' 0x1D24
|
|
|
|
italic-variant 'cyrghayn' 0x493
|
|
|
|
|
|
sketch # gamma
|
|
include MarkSet.p
|
|
|
|
local xmid : [mix SB RIGHTSB 0.46] + HALFSTROKE
|
|
include : dispiro
|
|
g4 (SB + 0.4 * STROKE * HVCONTRAST) (XH - O) [widths.rhs]
|
|
bezcontrols 0.33 0.17 1 0.62 6 important
|
|
flat xmid 0
|
|
curl xmid DESCENDER [heading DOWNWARD]
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RIGHTSB XH [heading DOWNWARD]
|
|
curl RIGHTSB (XH * 0.9) [heading DOWNWARD]
|
|
quadcontrols 0 0.3 6
|
|
g4 xmid 0 [widths.rhs : STROKE * 0.9]
|
|
save 'gamma' 0x3B3
|
|
|
|
sketch
|
|
include MarkSet.b
|
|
|
|
local xNeck : mix SB RIGHTSB 0.07
|
|
local bar : mix 0 XH 0.96
|
|
local xOTLeft : mix SB RIGHTSB 0.5
|
|
local fine : STROKE * 0.5
|
|
|
|
local sma : SMALLSMOOTHA * bar / XH
|
|
local smb : SMALLSMOOTHB * bar / XH
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 [mix MIDDLE RIGHTSB 0.85] ([mix XH CAP 0.8] - STROKE) [heading LEFTWARD]
|
|
alsothru 0.5 0.7
|
|
g4 MIDDLE (CAPO - STROKE)
|
|
archv 2
|
|
g4 (xNeck + STROKE) [mix (CAPO - STROKE) bar 0.5]
|
|
arcvh 2
|
|
g4 xOTLeft bar [heading RIGHTWARD]
|
|
alsothruthem : list {0.25 0.05} {0.5 0.13}
|
|
flat.ai (RIGHTSB - OX) (bar - smb)
|
|
curl.ai (RIGHTSB - OX) sma
|
|
arcvh
|
|
g4.left.mid (MIDDLE + CORRECTION_OMIDS) O
|
|
archv
|
|
flat.ai (SB + OX) smb
|
|
curl.ai (SB + OX) (bar - sma)
|
|
arcvh
|
|
g4 xOTLeft (bar - (STROKE - fine) / 2) [widths 0 fine]
|
|
|
|
save 'delta' 0x3B4
|
|
save 'cyrbe.SRB'
|
|
save 'latindelta' 0x1E9F
|
|
|
|
turned 'turndelta' 0x18D 'delta' MIDDLE (XH / 2) MarkSet.p
|
|
|
|
sketch # cyrbe
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.rhs (STROKE * CTHINB)
|
|
flat (SB + OX + STROKE * (1 - CTHINB) * HVCONTRAST) SMALLSMOOTHB
|
|
curl (SB + OX + STROKE * (1 - CTHINB) * HVCONTRAST) (XH - SMALLSMOOTHA)
|
|
arcvh
|
|
g4 (MIDDLE - CORRECTION_OMIDS) (CAP * 0.7 - O) [widths.rhs STROKE]
|
|
archv
|
|
flat.ai (RIGHTSB - OX) (XH - SMALLSMOOTHB)
|
|
curl.ai (RIGHTSB - OX) SMALLSMOOTHA
|
|
arcvh
|
|
g4 (MIDDLE + CORRECTION_OMIDS) O
|
|
archv
|
|
flat (SB + OX) SMALLSMOOTHB
|
|
curl (SB + OX) (XH - SMALLSMOOTHA)
|
|
alsothruthem [list {0.25 0.79} {0.5 0.87}] important
|
|
g4 (RIGHTSB - HALFSTROKE * HVCONTRAST) CAP
|
|
save 'cyrbe' 0x431
|
|
|
|
define [SmallEpsilonShape top hook] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 2 top
|
|
local midx : mix SB RIGHTSB 0.65
|
|
local midy : top * OVERLAYPOS
|
|
local sma : top - [mix (midy + stroke / 2) (top - O - stroke) (SMOOTHB / (SMOOTHA + SMOOTHB))] - TANSLANT * HVCONTRAST * STROKE
|
|
local smb : [mix (STROKE + O) (midy - stroke / 2) (SMOOTHB / (SMOOTHA + SMOOTHB))] + TANSLANT * HVCONTRAST * stroke
|
|
local fine : stroke * CTHIN
|
|
include : dispiro
|
|
g4 (RIGHTSB + O) (top - [fallback hook SHOOK]) [widths.lhs]
|
|
hookstart (top - O)
|
|
g4 (SB + OXE) (top - sma)
|
|
arcvh
|
|
flat MIDDLE (midy - (fine - stroke / 2)) [widths.heading fine 0 RIGHTWARD]
|
|
curl midx (midy - (fine - stroke / 2)) [heading RIGHTWARD]
|
|
include : dispiro
|
|
flat midx (midy + (fine - stroke / 2)) [widths.heading fine 0 LEFTWARD]
|
|
curl MIDDLE (midy + (fine - stroke / 2)) [heading LEFTWARD]
|
|
archv
|
|
g4 (SB + OXE + O * 2) smb [widths.lhs]
|
|
hookend O
|
|
g4 (RIGHTSB - O) [fallback hook SHOOK]
|
|
|
|
sketch # epsilon
|
|
include MarkSet.e
|
|
include : SmallEpsilonShape XH
|
|
save 'epsilon' 0x3B5
|
|
save 'latinepsilon' 0x25B
|
|
|
|
sketch # latinEpsilon
|
|
include MarkSet.capital
|
|
include : SmallEpsilonShape CAP
|
|
save 'latinEpsilon' 0x190
|
|
|
|
define [CyrZeShape top hook] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 2 top
|
|
local midx : mix RIGHTSB SB 0.65
|
|
local midy : top * OVERLAYPOS
|
|
local smb : top - [mix (midy + stroke / 2) (top - O - stroke) (SMOOTHA / (SMOOTHA + SMOOTHB))] + TANSLANT * HVCONTRAST * stroke
|
|
local sma : [mix (stroke + O) (midy - stroke / 2) (SMOOTHA / (SMOOTHA + SMOOTHB))] - TANSLANT * HVCONTRAST * stroke
|
|
local fine : stroke * CTHIN
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 (SB - O) (top - [fallback hook SHOOK])
|
|
hookstart (top - O)
|
|
g4 (RIGHTSB - OXE) (top - smb)
|
|
arcvh
|
|
flat MIDDLE (midy - (fine - stroke / 2)) [widths.heading 0 fine LEFTWARD]
|
|
curl midx (midy - (fine - stroke / 2)) [heading LEFTWARD]
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 (SB + O) [fallback hook SHOOK]
|
|
hookstart O
|
|
g4 (RIGHTSB - OXE - O * 2) sma
|
|
arcvh
|
|
flat MIDDLE (midy + (fine - stroke / 2)) [widths.heading fine 0 LEFTWARD]
|
|
curl midx (midy + (fine - stroke / 2)) [heading LEFTWARD]
|
|
|
|
sketch # cyrZe
|
|
include MarkSet.capital
|
|
include : CyrZeShape CAP HOOK
|
|
save 'cyrZe' 0x417
|
|
|
|
sketch # cyrze.BGR
|
|
include MarkSet.p
|
|
include : CyrZeShape CAP HOOK
|
|
apply-transform : Upright
|
|
apply-transform : Translate 0 (XH - CAP)
|
|
apply-transform : Italify
|
|
save 'cyrze.BGR'
|
|
|
|
sketch # cyrze
|
|
include MarkSet.e
|
|
include : CyrZeShape XH
|
|
save 'cyrze' 0x437
|
|
save 'revlatinepsilon' 0x25C
|
|
turned 'closeepsilon' 0x29A 'closeturnepsilon' MIDDLE (XH / 2)
|
|
|
|
|
|
sketch # Theta
|
|
include MarkSet.capital
|
|
include glyphs.O AS_BASE
|
|
include : HBar (SB + STROKE * HVCONTRAST - O * 3) (RIGHTSB - STROKE * HVCONTRAST + O * 3) CAPMIDDLE
|
|
save 'Theta' 0x398
|
|
|
|
sketch # theta
|
|
include MarkSet.b
|
|
include : OShape CAP 0 (SB - O) (RIGHTSB + O) STROKE (SMALLSMOOTHA * 100) (SMALLSMOOTHB * 100)
|
|
include : HBar (SB + HALFSTROKE) (RIGHTSB - HALFSTROKE) CAPMIDDLE
|
|
save 'theta' 0x3B8
|
|
|
|
|
|
sketch # zeta
|
|
include MarkSet.if
|
|
include : HBar SB (RIGHTSB + O) (CAP - HALFSTROKE)
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 (RIGHTSB + O) (CAP - STROKE)
|
|
bezcontrols 0.7 0.35 1 0.64 12
|
|
g4.down.mid (SB + STROKE * HVCONTRAST) [mix 0 CAP (0.54 * SMALLSMOOTHB / (SMALLSMOOTHA + SMALLSMOOTHB))]
|
|
arcvh
|
|
g4 [mix SB RIGHTSB 0.55] STROKE [heading RIGHTWARD]
|
|
archv 12
|
|
g4.down.mid RIGHTSB [mix DESCENDER STROKE 0.5] [heading DOWNWARD]
|
|
arcvh 12
|
|
flat (RIGHTSB - (STROKE - [mix DESCENDER STROKE 0.5]) * 1.1) DESCENDER [heading LEFTWARD]
|
|
curl [Math.min (RIGHTSB - (STROKE - [mix DESCENDER STROKE 0.5]) * 1.1 - 1) [mix SB RIGHTSB 0.5]] DESCENDER [heading LEFTWARD]
|
|
|
|
save 'zeta' 0x3B6
|
|
|
|
sketch # xi
|
|
include MarkSet.if
|
|
include : HBar SB (RIGHTSB + O) (CAP - HALFSTROKE)
|
|
|
|
local xbar : mix SB RIGHTSB 0.85
|
|
local ybar : mix 0 CAP 0.55
|
|
include : dispiro
|
|
widths.rhs
|
|
g4.left.start xbar (CAP - STROKE)
|
|
archv
|
|
g4 (SB - O * 2 + STROKE * HVCONTRAST) [mix (CAP - STROKE) ybar 0.6]
|
|
arcvh
|
|
g4.right.end (xbar - HALFSTROKE * TANSLANT) ybar [widths.rhs (STROKE * [mix CTHIN 1 0.5])]
|
|
include : dispiro
|
|
widths.rhs (STROKE * [mix CTHIN 1 0.5])
|
|
g4.left.start (xbar + HALFSTROKE * TANSLANT) (ybar - STROKE)
|
|
bezcontrols 0.7 0 1 0.6
|
|
g4 (SB + STROKE * HVCONTRAST) [mix 0 ybar 0.45] [widths.rhs]
|
|
arcvh
|
|
g4 [mix SB RIGHTSB 0.5] STROKE
|
|
archv
|
|
g4.down.mid RIGHTSB [mix DESCENDER STROKE 0.5] [heading DOWNWARD]
|
|
arcvh
|
|
flat (RIGHTSB - (STROKE - [mix DESCENDER STROKE 0.5]) * 1.1) DESCENDER [heading LEFTWARD]
|
|
curl [Math.min (RIGHTSB - (STROKE - [mix DESCENDER STROKE 0.5]) * 1.1 - 1) [mix SB RIGHTSB 0.5]] DESCENDER [heading LEFTWARD]
|
|
save 'xi' 0x3BE
|
|
|
|
sketch
|
|
include MarkSet.p
|
|
include glyphs.u
|
|
include : dispiro
|
|
widths.rhs
|
|
flat SB DESCENDER [heading UPWARD]
|
|
curl SB (DESCENDER / 2) [heading UPWARD]
|
|
straight.up.end SB SMALLSMOOTHB [widths.heading 0 [adviceBlackness 4] UPWARD]
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif SB XH SIDEJUT
|
|
|
|
save 'mu' 0x3BC
|
|
|
|
sketch
|
|
include MarkSet.capital
|
|
include : HBar [mix SB RIGHTSB 0.125] [mix RIGHTSB SB 0.125] [mix 0 CAP 0.54]
|
|
include : HBar (SB + OX) (RIGHTSB - OX) (CAP - HALFSTROKE)
|
|
include : HBar (SB + OX) (RIGHTSB - OX) (0 + HALFSTROKE)
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif (SB + OX) CAP VJUT
|
|
include : DownwardRightSerif (RIGHTSB - OX) CAP VJUT
|
|
include : UpwardLeftSerif (SB + OX) 0 VJUT
|
|
include : UpwardRightSerif (RIGHTSB - OX) 0 VJUT
|
|
|
|
save 'Xi' 0x39E
|
|
|
|
|
|
define [PiShape] : params [top bottom [shrinkrate 0.05] _fine noserif [endShrink 0] [div 1]] : glyph-construction
|
|
local df : DivFrame (div || 1)
|
|
local fine : fallback _fine STROKE
|
|
local shrink : if (!noserif && SLAB) 0 (shrinkrate * (df.rightSB - SB))
|
|
local endexpand : if (!noserif && SLAB) 0 (- endShrink * (df.rightSB - SB) || shrink / 2)
|
|
include : HBarTop (SB - endexpand) (df.rightSB + endexpand) top fine
|
|
include : VBarLeft (SB + shrink) bottom (top - fine / 2) fine
|
|
include : VBarRight (df.rightSB - shrink) bottom (top - fine / 2) fine
|
|
|
|
if (!noserif && SLAB) : begin
|
|
include : CenterBottomSerif (SB + shrink + fine * 0.5 * HVCONTRAST) bottom JUT fine
|
|
include : CenterBottomSerif (df.rightSB - shrink - fine * 0.5 * HVCONTRAST) bottom JUT fine
|
|
include : CenterTopSerif (SB + shrink + fine * 0.5 * HVCONTRAST) top JUT fine
|
|
include : CenterTopSerif (df.rightSB - shrink - fine * 0.5 * HVCONTRAST) top JUT fine
|
|
|
|
sketch # Pi
|
|
include MarkSet.capital
|
|
include : PiShape CAP 0 (shrinkrate -- 0)
|
|
save 'Pi' 0x3A0
|
|
save 'cyrPe' 0x41F
|
|
|
|
sketch # cyrpe.upright
|
|
include MarkSet.e
|
|
include : PiShape XH 0 (shrinkrate -- 0.05) (endShrink -- 0.05)
|
|
save 'cyrpe.upright'
|
|
|
|
sketch # cyrpe.SRB
|
|
include glyphs.u AS_BASE
|
|
include glyphs.macronAbove
|
|
save 'cyrpe.SRB'
|
|
|
|
italic-variant 'cyrpe' 0x43f
|
|
sketch # pi
|
|
include MarkSet.e
|
|
include : PiShape XH 0 (noserif -- true) (shrinkrate -- 0.06)
|
|
save 'pi' 0x3C0
|
|
|
|
list PiShape
|
|
|
|
|
|
define [SigmaShape top bottom _fine div] : glyph-construction
|
|
local cor 1.15
|
|
local fine : fallback _fine STROKE
|
|
local df : DivFrame (div || 1)
|
|
|
|
include : HBarTop SB df.rightSB top fine
|
|
include : HBarBottom SB df.rightSB bottom fine
|
|
|
|
local midx : mix SB df.rightSB 0.4
|
|
start-from SB (bottom + fine)
|
|
line-to (SB + fine * cor) (bottom + fine)
|
|
line-to (midx + fine * cor) [mix bottom top 0.5]
|
|
line-to (SB + fine * cor) (top - fine)
|
|
line-to SB (top - fine)
|
|
line-to midx [mix bottom top 0.5]
|
|
reverse-last
|
|
|
|
if SLAB : begin
|
|
include : DownwardRightSerif df.rightSB top VJUT
|
|
include : UpwardRightSerif df.rightSB bottom VJUT
|
|
|
|
sketch # Sigma
|
|
set-width WIDTH
|
|
include MarkSet.capital
|
|
|
|
include : SigmaShape CAP 0
|
|
save 'Sigma' 0x3A3
|
|
save 'latinSigma' 0x1A9
|
|
|
|
list SigmaShape
|
|
|
|
|
|
sketch # Phi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
|
|
local y1 : CAP * [if SLAB 0.175 0.125]
|
|
local y2 : CAP * [if SLAB 0.825 0.875]
|
|
include : VBar df.middle 0 (y1 + HALFSTROKE)
|
|
include : OShape y2 y1 (df.leftSB + O) (df.rightSB - O) df.mvs (SMOOTHA * df.div) (SMOOTHB * df.div)
|
|
include : VBar df.middle y1 y2 df.mvs
|
|
include : VBar df.middle (y2 - HALFSTROKE) CAP
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifMT' : CenterTopSerif df.middle CAP JUT
|
|
include : tagged 'serifMB' : CenterBottomSerif df.middle 0 JUT
|
|
save 'Phi' 0x3A6
|
|
save 'cyrEf' 0x424
|
|
|
|
sketch # taillessphi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
|
|
local x0 : mix df.leftSB df.rightSB 0.1
|
|
local y1 : mix 0 XH 0.75
|
|
local x1 : df.leftSB + OX * 2
|
|
local y3 : XH * 0.66
|
|
local y4 : XH * 0.65
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
g4 x0 XH
|
|
g4 x1 (XH * 0.55)
|
|
arcvh
|
|
g4 (df.middle + CORRECTION_OMIDS) O
|
|
archv
|
|
g4 (df.width - x1) (XH * 0.55)
|
|
arcvh 8
|
|
g4.left.mid [mix (df.width - x1) (df.middle - df.mvs / 2 * HVCONTRAST) 0.525] XH [heading LEFTWARD]
|
|
archv
|
|
flat (df.middle - df.mvs / 2 * HVCONTRAST) y3
|
|
curl (df.middle - df.mvs / 2 * HVCONTRAST) (df.mvs * 0.2) [heading DOWNWARD]
|
|
save 'taillessphi' 0x2C77
|
|
|
|
sketch # phi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.p
|
|
include glyphs.taillessphi
|
|
include : VBar df.middle DESCENDER (df.mvs * 0.2)
|
|
save 'phi' 0x3C6
|
|
|
|
sketch # varphi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.if
|
|
|
|
local y1 0
|
|
local y2 XH
|
|
include : VBar df.middle DESCENDER (y1 + HALFSTROKE)
|
|
include : OShape y2 y1 df.leftSB df.rightSB df.mvs (SMOOTHA * df.div) (SMOOTHB * df.div) nothing true
|
|
include : VBar df.middle y1 y2 df.mvs
|
|
include : VBar df.middle (y2 - HALFSTROKE) CAP
|
|
save 'varphi' 0x3D5
|
|
|
|
sketch # cyref
|
|
local df : DivFrame para.diversityM 3
|
|
include glyphs.varphi AS_BASE ALSO_METRICS
|
|
if SLAB : begin
|
|
include : tagged 'serifMT' : CenterTopSerif df.middle CAP JUT
|
|
include : tagged 'serifMB' : CenterBottomSerif df.middle DESCENDER JUT
|
|
save 'cyref' 0x444
|
|
save 'latinphi' 0x278
|
|
|
|
sketch # Psi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
|
|
local y : CAP * 0.2
|
|
local y2 : CAP * (1 - 0.2 / df.div)
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.leftSB y2 [heading DOWNWARD]
|
|
curl df.leftSB (y + (SMOOTHB * df.div))
|
|
arcvh
|
|
g4 df.middle y [heading RIGHTWARD]
|
|
archv
|
|
flat df.rightSB (y + (SMOOTHA * df.div))
|
|
curl df.rightSB y2 [heading UPWARD]
|
|
include : VBar df.middle y CAP df.mvs
|
|
include : VBar df.middle 0 (y + HALFSTROKE)
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif df.leftSB y2 SIDEJUT
|
|
include : tagged 'serifRT' : RightwardTopSerif df.rightSB y2 SIDEJUT
|
|
include : tagged 'serifMT' : CenterTopSerif df.middle CAP JUT
|
|
include : tagged 'serifMB' : CenterBottomSerif df.middle 0 JUT
|
|
|
|
save 'Psi' 0x3A8
|
|
|
|
sketch # smcpPsi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
|
|
local y : XH * 0.3
|
|
local y2 XH
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.leftSB y2 [heading DOWNWARD]
|
|
curl df.leftSB (y + (SMOOTHB * df.div))
|
|
arcvh
|
|
g4 df.middle y [heading RIGHTWARD]
|
|
archv
|
|
flat df.rightSB (y + (SMOOTHA * df.div))
|
|
curl df.rightSB y2 [heading UPWARD]
|
|
include : VBar df.middle y XH df.mvs
|
|
include : VBar df.middle 0 (y + HALFSTROKE)
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif df.leftSB y2 SIDEJUT
|
|
include : tagged 'serifRT' : RightwardTopSerif df.rightSB y2 SIDEJUT
|
|
include : tagged 'serifMB' : CenterBottomSerif df.middle 0 JUT
|
|
|
|
save 'smcpPsi' 0x1D2A
|
|
|
|
sketch # psi
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.if
|
|
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.leftSB XH [heading DOWNWARD]
|
|
curl df.leftSB SMALLSMOOTHB
|
|
arcvh
|
|
g4 df.middle O [heading RIGHTWARD]
|
|
archv
|
|
flat df.rightSB SMALLSMOOTHA
|
|
curl df.rightSB XH [heading UPWARD]
|
|
include : VBar df.middle 0 CAP df.mvs
|
|
include : VBar df.middle DESCENDER HALFSTROKE
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif df.leftSB XH SIDEJUT
|
|
tag-contour 'serifLT'
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif df.rightSB XH SIDEJUT
|
|
save 'psi' 0x3C8
|
|
|
|
|
|
define [OmegaShape top extend sma smb] : glyph-construction
|
|
local fine : STROKE * CTHIN
|
|
local x1 [mix SB RIGHTSB 0.4]
|
|
local x2 (WIDTH - x1)
|
|
local yattach : top * extend + STROKE
|
|
include : dispiro
|
|
g4 x1 (yattach - fine) [widths.heading 0 fine LEFTWARD]
|
|
archv
|
|
flat SB (yattach - STROKE + smb) [widths 0 STROKE]
|
|
curl SB (top - sma)
|
|
arcvh
|
|
g4 (MIDDLE - CORRECTION_OMIDS) (top - O)
|
|
archv
|
|
flat RIGHTSB (top - smb)
|
|
curl RIGHTSB (yattach - STROKE + sma)
|
|
arcvh
|
|
g4 x2 (yattach - fine) [widths.heading 0 fine LEFTWARD]
|
|
include : VBarRight x1 0 (yattach) fine
|
|
include : HBar SB x1 HALFSTROKE
|
|
include : VBarLeft x2 0 (yattach) fine
|
|
include : HBar x2 RIGHTSB HALFSTROKE
|
|
|
|
sketch # latinUpsilon1
|
|
include MarkSet.capital
|
|
include : OmegaShape CAP 0.08 SMOOTHA SMOOTHB
|
|
save 'Omega' 0x3A9
|
|
|
|
include : FlipAround MIDDLE (CAP / 2)
|
|
save 'latinUpsilon1' 0x1B1
|
|
|
|
sketch # latinupsilon1
|
|
include MarkSet.e
|
|
include : OmegaShape XH 0.08 SMALLSMOOTHA SMALLSMOOTHB
|
|
save 'latinomega' 0xAB65
|
|
|
|
include : FlipAround MIDDLE (XH / 2)
|
|
save 'latinupsilon1' 0x28A
|
|
|
|
|
|
sketch # omega
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include [DivFrame df.div].markSet.e
|
|
|
|
local fine : adviceBlackness 3.25 df.div
|
|
local mfine : fine * CTHIN
|
|
local x0 : mix df.leftSB df.rightSB 0.1
|
|
local y0 : XH - STROKE * 0.2
|
|
local y1 : mix 0 XH 0.8
|
|
local x1 : df.leftSB + OX
|
|
local y3 : XH / 2
|
|
local y4 : XH * 0.65
|
|
|
|
include : dispiro
|
|
widths.lhs fine
|
|
g4 x0 y0
|
|
g4 x1 (XH / 2)
|
|
arcvh 8
|
|
g4 [mix x1 (df.middle + fine / 2 * HVCONTRAST) 0.5] O [heading RIGHTWARD]
|
|
archv 8
|
|
flat (df.middle + (mfine - fine / 2) * HVCONTRAST) y3 [widths.heading mfine 0 UPWARD]
|
|
curl (df.middle + (mfine - fine / 2) * HVCONTRAST) y4 [heading UPWARD]
|
|
end [function : set this.angles 4]
|
|
include : dispiro
|
|
widths.rhs fine
|
|
g4 (df.width - x0) y0
|
|
g4 (df.width - x1) (XH / 2)
|
|
arcvh 8
|
|
g4 [mix (df.width - x1) (df.middle - fine / 2 * HVCONTRAST) 0.5] O [heading LEFTWARD]
|
|
archv 8
|
|
flat (df.middle - (mfine - fine / 2) * HVCONTRAST) y3 [widths.heading 0 mfine UPWARD]
|
|
curl (df.middle - (mfine - fine / 2) * HVCONTRAST) y4 [heading UPWARD]
|
|
end [function : set this.angles 4]
|
|
|
|
save 'omega' 0x3C9
|
|
|
|
sketch # pomega
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
|
|
include glyphs.omega AS_BASE
|
|
include : HBar df.leftSB df.rightSB (XH - HALFSTROKE)
|
|
|
|
save 'pomega' 0x3D6
|
|
|
|
sketch # closeomega
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include [DivFrame df.div].markSet.e
|
|
local fine : adviceBlackness 3.25
|
|
local mfine : fine * CTHIN
|
|
local x0 : df.middle - CORRECTION_OMIDS
|
|
local y0 : XH - O
|
|
local y1 : mix 0 XH 0.45
|
|
local x1 : df.leftSB + OX
|
|
local y3 : XH / 2
|
|
local y4 : XH * 0.65
|
|
include : dispiro
|
|
widths.rhs mfine
|
|
flat (df.middle + (mfine - fine / 2) * HVCONTRAST) y4 [heading DOWNWARD]
|
|
curl (df.middle + (mfine - fine / 2) * HVCONTRAST) y3 [heading DOWNWARD]
|
|
arcvh 8
|
|
g4 [mix x1 (df.middle + fine / 2 * HVCONTRAST) 0.5] O [widths.heading 0 fine LEFTWARD]
|
|
archv 8
|
|
g4 x1 y1
|
|
arcvh
|
|
g4 x0 y0
|
|
archv
|
|
g4 (df.width - x1) y1
|
|
arcvh 8
|
|
g4 [mix (df.width - x1) (df.middle - fine / 2 * HVCONTRAST) 0.5] O [heading LEFTWARD]
|
|
archv 8
|
|
flat (df.middle - (mfine - fine / 2) * HVCONTRAST) y3 [widths.heading 0 mfine UPWARD]
|
|
curl (df.middle - (mfine - fine / 2) * HVCONTRAST) y4 [heading UPWARD]
|
|
end [function : set this.angles 4]
|
|
save 'closeomega' 0x277
|
|
|
|
###########################################################################################
|
|
# UNIFIED LETTERFORMS : CYRILLIC ORIGINALS
|
|
###########################################################################################
|
|
|
|
define [CyrYeriShape top _left _right _fine _jut] : glyph-construction
|
|
local fine : fallback _fine STROKE
|
|
local left : fallback _left SB
|
|
local right : fallback _right RIGHTSB
|
|
local jut : fallback _jut JUT
|
|
|
|
local bowl : top * 0.55 + HALFSTROKE
|
|
local turnRadius : bowl * 0.45
|
|
local turnbottom : mix 0 bowl (SMOOTHA / (SMOOTHA + SMOOTHB))
|
|
local trShrink [Math.pow ((right - left) / (RIGHTSB - SB)) 0.5]
|
|
include : dispiro
|
|
widths.lhs fine
|
|
flat (left + STROKE * 0.2) 0 [heading RIGHTWARD]
|
|
curl ([Math.max (left + fine * HVCONTRAST) (right - turnRadius * trShrink)] + CORRECTION_OMIDX * fine) 0
|
|
archv 8
|
|
g4 (right - OX) turnbottom
|
|
arcvh 8
|
|
flat ([Math.max (left + fine * HVCONTRAST) (right - turnRadius * trShrink)] - CORRECTION_OMIDX * fine) bowl
|
|
curl (left + STROKE * 0.2) bowl [heading LEFTWARD]
|
|
include : VBarLeft left 0 top fine
|
|
if SLAB : begin
|
|
include : LeftwardBottomSerif left 0 (jut - fine / 2 * HVCONTRAST)
|
|
tag-contour 'serifYeriLB'
|
|
include : CenterTopSerif (left + fine / 2 * HVCONTRAST) top jut
|
|
tag-contour 'serifYeriLT'
|
|
|
|
define [RevCyrYeriShape top _left _right _fine _jut] : glyph-construction
|
|
local fine : fallback _fine STROKE
|
|
local left : fallback _left SB
|
|
local right : fallback _right RIGHTSB
|
|
local jut : fallback _jut JUT
|
|
|
|
local bowl : top * 0.55 + HALFSTROKE
|
|
|
|
local turnRadius : bowl * 0.45
|
|
local turnbottom : mix 0 bowl (SMOOTHB / (SMOOTHA + SMOOTHB))
|
|
local trShrink [Math.pow ((right - left) / (RIGHTSB - SB)) 0.5]
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (right - STROKE * 0.2) 0 [heading LEFTWARD]
|
|
curl (left + turnRadius * trShrink + CORRECTION_OMIDX * fine) 0
|
|
archv
|
|
g4 (left + O) turnbottom [widths.rhs fine]
|
|
arcvh
|
|
flat (left + turnRadius * trShrink - CORRECTION_OMIDX * fine) bowl [widths.rhs]
|
|
curl (right - STROKE * 0.2) bowl [heading RIGHTWARD]
|
|
include : VBarRight right 0 top fine
|
|
if SLAB : begin
|
|
include : RightwardBottomSerif right 0 (jut - fine / 2 * HVCONTRAST)
|
|
tag-contour 'serifYeriRB'
|
|
include : CenterTopSerif (right - fine / 2 * HVCONTRAST) top jut
|
|
tag-contour 'serifYeriRT'
|
|
|
|
sketch # cyrYeri
|
|
include MarkSet.capital
|
|
include : CyrYeriShape CAP SB RIGHTSB
|
|
|
|
save 'cyrYeri' 0x42C
|
|
|
|
sketch # cyryeri
|
|
include MarkSet.e
|
|
include : CyrYeriShape XH SB RIGHTSB
|
|
|
|
save 'cyryeri' 0x44C
|
|
|
|
sketch # cyrBe
|
|
include glyphs.cyrYeri AS_BASE
|
|
include : HBar SB [mix SB RIGHTSB 0.9] (CAP - HALFSTROKE)
|
|
if SLAB : begin
|
|
include : DownwardRightSerif [mix SB RIGHTSB 0.9] CAP VJUT
|
|
save 'cyrBe' 0x411
|
|
save 'latinBe' 0x182
|
|
|
|
sketch # ZhuangToneSix
|
|
include glyphs.cyrYeri AS_BASE
|
|
eject-contour 'serifYeriLT'
|
|
local s : Math.max STROKE (XH * 0.1)
|
|
start-from (SB - O) CAP
|
|
line-to SB CAP
|
|
line-to (SB - s) (CAP - s)
|
|
line-to SB (CAP - s * 2)
|
|
line-to (SB - O) (CAP - s * 2)
|
|
reverse-last
|
|
save 'ZhuangToneSix' 0x184
|
|
|
|
sketch # latinDe
|
|
include MarkSet.capital
|
|
include : RevCyrYeriShape CAP
|
|
include : HBarTop [mix RIGHTSB SB 0.9] (RIGHTSB + O) CAP
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif [mix RIGHTSB SB 0.9] CAP VJUT
|
|
save 'latinDe' 0x18B
|
|
|
|
define [CyrYerShape top] : glyph-construction
|
|
local left : if SLAB ([mix SB RIGHTSB 0.35] - MVERTSTROKE / 2 * HVCONTRAST) [mix SB RIGHTSB 0.2]
|
|
local barleft : mix 0 SB [if SLAB 0.25 0.375]
|
|
include : CyrYeriShape top left (RIGHTSB - O * 2)
|
|
include : HBarTop barleft (STROKE * 0.1 + left) top
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif barleft top VJUT (MVERTSTROKE / HVCONTRAST)
|
|
|
|
sketch # cyrYer
|
|
include MarkSet.capital
|
|
include : CyrYerShape CAP
|
|
save 'cyrYer' 0x42A
|
|
|
|
sketch # cyryer
|
|
include MarkSet.e
|
|
include : CyrYerShape XH
|
|
save 'cyryer' 0x44A
|
|
|
|
define [CyrYeryShape top df] : glyph-construction
|
|
local overshoot : O * 2
|
|
include : CyrYeriShape top (df.leftSB + overshoot) [mix (df.rightSB - df.mvs * HVCONTRAST) (MIDDLE + df.mvs / 2 * HVCONTRAST) (0.75 / df.div)] df.mvs (JUT * 0.75)
|
|
include : VBarRight (df.rightSB - overshoot) 0 top df.mvs
|
|
if SLAB : begin
|
|
include : CenterTopSerif (df.rightSB - overshoot - df.mvs / 2 * HVCONTRAST) top (JUT * 0.75)
|
|
include : CenterBottomSerif (df.rightSB - overshoot - df.mvs / 2 * HVCONTRAST) 0 (JUT * 0.75)
|
|
|
|
sketch # cyrYery
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrYeryShape CAP df
|
|
save 'cyrYery' 0x42B
|
|
sketch # cyryery
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrYeryShape XH df
|
|
save 'cyryery' 0x44B
|
|
|
|
define [CyrIShape top] : glyph-construction
|
|
local topstroke : adviceBlackness 4
|
|
local halftopstroke : topstroke / 2
|
|
include : dispiro
|
|
widths.lhs
|
|
flat RIGHTSB 0 [heading UPWARD]
|
|
curl RIGHTSB (top * 0.4) [heading UPWARD]
|
|
straight.up.end RIGHTSB top [widths.heading topstroke 0 UPWARD]
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB top [heading DOWNWARD]
|
|
curl SB (top * 0.6) [heading DOWNWARD]
|
|
straight.down.end SB 0 [widths.heading topstroke 0 DOWNWARD]
|
|
include : dispiro
|
|
flat (RIGHTSB - halftopstroke) top [widths.heading 0 topstroke DOWNWARD]
|
|
curl (SB + halftopstroke) 0 [widths.heading topstroke 0 DOWNWARD]
|
|
include : AICyrISerifs top
|
|
|
|
sketch # cyrI
|
|
include MarkSet.capital
|
|
include : CyrIShape CAP
|
|
|
|
save 'cyrI' 0x418
|
|
|
|
sketch # cyri.upright
|
|
include MarkSet.e
|
|
include : CyrIShape XH
|
|
|
|
save 'cyri.upright'
|
|
|
|
sketch # cyri.italic
|
|
include glyphs.u AS_BASE
|
|
|
|
save 'cyri.italic'
|
|
|
|
italic-variant 'cyri' 0x438
|
|
|
|
|
|
define [CyrTseShape top] : glyph-construction
|
|
include : VBarLeft SB 0 top
|
|
include : HBarBottom SB RIGHTSB 0
|
|
include : VBarRight RIGHTSB 0 top
|
|
include : CyrDescender RIGHTSB 0.05
|
|
if SLAB : begin
|
|
include : AIVSerifs top
|
|
include : LeftwardBottomSerif SB 0 SIDEJUT
|
|
include : RightwardBottomSerif RIGHTSB 0 SIDEJUT
|
|
|
|
sketch # cyrTse
|
|
include MarkSet.capital
|
|
include : CyrTseShape CAP
|
|
|
|
save 'cyrTse' 0x426
|
|
|
|
sketch # cyrtse.upright
|
|
include MarkSet.e
|
|
include : CyrTseShape XH
|
|
save 'cyrtse.upright'
|
|
|
|
sketch # cyrtse.italic
|
|
include MarkSet.e
|
|
include glyphs.u
|
|
eject-contour 'serifLT'
|
|
include : CyrDescender RIGHTSB 0.05
|
|
save 'cyrtse.italic'
|
|
|
|
italic-variant 'cyrtse' 0x446
|
|
|
|
define [CyrDzheShape top] : glyph-construction
|
|
include : VBarLeft SB 0 top
|
|
include : HBarBottom SB RIGHTSB 0
|
|
include : VBarRight RIGHTSB 0 top
|
|
include : VBar MIDDLE DESCENDER STROKE
|
|
if SLAB : begin
|
|
include : AIVSerifs top
|
|
include : LeftwardBottomSerif SB 0 SIDEJUT
|
|
include : RightwardBottomSerif RIGHTSB 0 SIDEJUT
|
|
|
|
sketch # cyrDzhe
|
|
include MarkSet.if
|
|
include : CyrDzheShape CAP
|
|
|
|
save 'cyrDzhe' 0x40F
|
|
|
|
sketch # cyrdzhe.upright
|
|
include MarkSet.p
|
|
include : CyrDzheShape XH
|
|
save 'cyrdzhe.upright'
|
|
|
|
sketch # cyrdzhe.italic
|
|
include glyphs.u AS_BASE
|
|
include glyphs.barBelow
|
|
save 'cyrdzhe.italic'
|
|
|
|
italic-variant 'cyrdzhe' 0x45F
|
|
|
|
|
|
define [CyrDeShape top] : glyph-construction
|
|
local descenderOverflow : if SLAB SIDEJUT ((RIGHTSB - SB) * 0.075)
|
|
local cutleft SB
|
|
local cutright RIGHTSB
|
|
local topleft : mix cutleft cutright 0.15
|
|
include : HBarBottom (cutleft - descenderOverflow) (cutright + descenderOverflow) 0
|
|
include : VBarRight cutright 0 top
|
|
include : halfXStrand false (topleft + STROKE * HVCONTRAST) top (cutleft + HALFSTROKE * HVCONTRAST * 0.8) HALFSTROKE 0.1 0.75 0.5
|
|
include : VBarLeft (cutleft - descenderOverflow) (-LONGJUT + HALFSTROKE) 0
|
|
include : VBarRight (cutright + descenderOverflow) (-LONGJUT + HALFSTROKE) 0
|
|
|
|
if SLAB : then
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (topleft - descenderOverflow) top
|
|
curl (cutright + descenderOverflow) top
|
|
: else
|
|
include : HBarTop topleft cutright top
|
|
|
|
sketch # cyrDe
|
|
include MarkSet.if
|
|
include : CyrDeShape CAP
|
|
|
|
save 'cyrDe' 0x414
|
|
|
|
sketch # cyrde.upright
|
|
include MarkSet.e
|
|
include : CyrDeShape XH
|
|
|
|
save 'cyrde.upright'
|
|
|
|
sketch # cyrde.italic
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.lhs (STROKE * CTHINB)
|
|
flat (RIGHTSB - OX - STROKE * HVCONTRAST * (1 - CTHINB)) SMALLSMOOTHA
|
|
curl (RIGHTSB - OX - STROKE * HVCONTRAST * (1 - CTHINB)) (XH - SMALLSMOOTHB)
|
|
arcvh
|
|
g4 (MIDDLE - CORRECTION_OMIDS) (CAP * 0.7 - O) [widths.lhs]
|
|
archv
|
|
flat.ai (SB + OX) (XH - SMALLSMOOTHA)
|
|
curl.ai (SB + OX) SMALLSMOOTHB
|
|
arcvh
|
|
g4 (MIDDLE + CORRECTION_OMIDS) O
|
|
archv
|
|
flat (RIGHTSB - OX) SMALLSMOOTHA
|
|
curl (RIGHTSB - OX) (XH - SMALLSMOOTHB)
|
|
quadcontrols 0 0.8
|
|
g4 (SB + STROKE * 1.1) CAP
|
|
|
|
save 'cyrde.italic'
|
|
|
|
italic-variant 'cyrde' 0x434
|
|
|
|
|
|
define [CyrElShape top] : glyph-construction
|
|
local cutleft : mix SB RIGHTSB 0.135
|
|
local cutleft2 : mix SB RIGHTSB 0.075
|
|
local cutright : mix SB RIGHTSB 1
|
|
include : VBarRight cutright 0 top
|
|
include : HBar cutleft cutright (top - HALFSTROKE)
|
|
include : LegShape
|
|
ztop -- (cutleft <> top)
|
|
zbot -- ([mix SB 0 [if SLAB 1 0.75]] <> 0)
|
|
xb -- cutleft2
|
|
if SLAB : begin
|
|
include : RightwardTopSerif cutright top SIDEJUT
|
|
include : LeftwardTopSerif cutleft top SIDEJUT
|
|
include : CenterBottomSerif (cutright - HALFSTROKE * HVCONTRAST) 0 JUT
|
|
|
|
sketch # cyrEl
|
|
include MarkSet.capital
|
|
include : CyrElShape CAP
|
|
|
|
save 'cyrEl' 0x41B
|
|
|
|
sketch # cyrel
|
|
include MarkSet.e
|
|
include : CyrElShape XH
|
|
save 'cyrel' 0x43B
|
|
|
|
|
|
define [CyrZheShape top midtop df] : glyph-construction
|
|
local fine : adviceBlackness 3.3 df.div
|
|
local midx : mix df.leftSB df.middle 0.3
|
|
define [CyrAngleShape] : glyph-construction
|
|
local cor HVCONTRAST
|
|
local overshoot : O * 3 * df.div
|
|
start-from (df.leftSB + overshoot) 0
|
|
line-to (df.leftSB + fine * cor + overshoot) 0
|
|
line-to (midx + fine * cor) (top / 2)
|
|
line-to (df.leftSB + fine * cor + overshoot) top
|
|
line-to (df.leftSB + overshoot) top
|
|
line-to midx (top / 2)
|
|
reverse-last
|
|
include : CyrAngleShape
|
|
include : FlipAround df.middle (top / 2)
|
|
include : CyrAngleShape
|
|
include : VBar df.middle 0 midtop fine
|
|
include : HBar midx (df.width - midx) (top / 2) fine
|
|
if SLAB : begin
|
|
define fineK 0.1
|
|
include : LeftwardTopSerif (df.leftSB + fine * fineK) top SIDEJUT
|
|
include : LeftwardBottomSerif (df.leftSB + fine * fineK) 0 SIDEJUT
|
|
include : RightwardTopSerif (df.rightSB - fine * fineK) top SIDEJUT
|
|
include : RightwardBottomSerif (df.rightSB - fine * fineK) 0 SIDEJUT
|
|
|
|
sketch # cyrZhe
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrZheShape CAP CAP df
|
|
save 'cyrZhe' 0x416
|
|
composite glyphs.cyrZhe
|
|
CyrDescender ([DivFrame para.diversityM 3].rightSB - O * 2) nothing true
|
|
into-unicode 0x496
|
|
|
|
sketch # cyrzhe
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrZheShape XH XH df
|
|
save 'cyrzhe' 0x436
|
|
composite glyphs.cyrzhe
|
|
CyrDescender ([DivFrame para.diversityM 3].rightSB - O * 2) nothing true
|
|
into-unicode 0x497
|
|
|
|
sketch # cyrzhe.BGR
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrZheShape XH CAP df
|
|
save 'cyrzhe.BGR'
|
|
|
|
define [CyrBigYusShape top yp df] : glyph-construction
|
|
local fine : adviceBlackness 3.3 df.div
|
|
local cor HVCONTRAST
|
|
local midx : mix df.leftSB df.middle 0.3
|
|
local midx2 : Math.min (df.middle - fine * cor) [mix df.leftSB df.middle 0.75]
|
|
local yb : top * yp
|
|
local tovershoot 2
|
|
|
|
start-from (df.leftSB + O * 2) 0
|
|
line-to (df.leftSB + fine * cor + O * 2) 0
|
|
line-to (midx + fine * cor) yb
|
|
line-to midx yb
|
|
reverse-last
|
|
|
|
start-from (midx2 + fine * cor) yb
|
|
line-to (df.leftSB + fine * cor + O * tovershoot) top
|
|
line-to (df.leftSB + O * tovershoot) top
|
|
line-to midx2 yb
|
|
reverse-last
|
|
|
|
start-from (df.width - df.leftSB - O * 2) 0
|
|
line-to (df.width - df.leftSB - fine * cor - O * 2) 0
|
|
line-to (df.width - midx - fine * cor) yb
|
|
line-to (df.width - midx) yb
|
|
|
|
start-from (df.width - midx2 - fine * cor) yb
|
|
line-to (df.width - df.leftSB - fine * cor - O * tovershoot) top
|
|
line-to (df.width - df.leftSB - O * tovershoot) top
|
|
line-to (df.width - midx2) yb
|
|
|
|
|
|
include : VBar df.middle 0 yb fine
|
|
include : HBarTop midx (df.width - midx) yb fine
|
|
include : HBarTop (df.leftSB + O * tovershoot + HVCONTRAST * fine * 0.99) (df.rightSB - O * tovershoot - HVCONTRAST * fine * 0.99) top fine
|
|
|
|
sketch # cyrbigYus
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrBigYusShape CAP 0.575 df
|
|
save 'cyrbigYus' 0x46A
|
|
sketch # cyrbigyus
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrBigYusShape XH 0.55 df
|
|
save 'cyrbigyus' 0x46B
|
|
|
|
define [CyrSmallYusShape top df straightBar] : glyph-construction
|
|
local fine : adviceBlackness 3.3 df.div
|
|
include : VShape top fine straightBar df.div
|
|
eject-contour 'serifLT'
|
|
eject-contour 'serifRT'
|
|
include : FlipAround df.middle (top / 2)
|
|
local p : if straightBar
|
|
linreg 18 0.24 108 0.24 STROKE
|
|
linreg 18 0.16 108 0.16 STROKE
|
|
local bary (top / 2)
|
|
if (SLAB && !para.isItalic) : set p : p * 1.33
|
|
include : HBarTop [mix df.leftSB df.rightSB p] [mix df.rightSB df.leftSB p] bary fine
|
|
include : VBar df.middle bary 0 fine
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : LeftwardBottomSerif df.leftSB 0 SIDEJUT
|
|
include : tagged 'serifRB' : RightwardBottomSerif df.rightSB 0 SIDEJUT
|
|
|
|
sketch # cyrsmallYus
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
branch
|
|
include : CyrSmallYusShape CAP df true
|
|
save 'cyrsmallYus.straight'
|
|
branch
|
|
include : CyrSmallYusShape CAP df false
|
|
save 'cyrsmallYus.curly'
|
|
sketch # cyrsmallyus
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
branch
|
|
include : CyrSmallYusShape XH df true
|
|
save 'cyrsmallyus.straight'
|
|
branch
|
|
include : CyrSmallYusShape XH df false
|
|
save 'cyrsmallyus.curly'
|
|
select-variant 'cyrsmallYus' 0x466 (follow -- 'Delta')
|
|
select-variant 'cyrsmallyus' 0x467 (follow -- 'Delta')
|
|
|
|
define [CyrShaShape top df] : glyph-construction
|
|
include : union
|
|
HBarBottom df.leftSB df.rightSB 0
|
|
VBarLeft df.leftSB 0 top df.mvs
|
|
VBarRight df.rightSB 0 top df.mvs
|
|
VBar df.middle 0 top df.mvs
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : LeftwardBottomSerif df.leftSB 0 SIDEJUT
|
|
include : tagged 'serifRB' : RightwardBottomSerif df.rightSB 0 SIDEJUT
|
|
|
|
local jut : JUT * df.mvs / STROKE + O
|
|
if (df.width > jut * 7) : begin
|
|
include : tagged 'serifLT'
|
|
CenterTopSerif (df.leftSB + 0.5 * df.mvs * HVCONTRAST) top jut df.mvs
|
|
include : tagged 'serifMT'
|
|
CenterTopSerif df.middle top jut df.mvs
|
|
include : tagged 'serifRT'
|
|
CenterTopSerif (df.rightSB - 0.5 * df.mvs * HVCONTRAST) top jut df.mvs
|
|
: else : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif df.leftSB top SIDEJUT
|
|
include : tagged 'serifRT' : RightwardTopSerif df.rightSB top SIDEJUT
|
|
|
|
sketch # cyrSha
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrShaShape CAP df
|
|
|
|
save 'cyrSha' 0x428
|
|
|
|
sketch # cyrsha.upright
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrShaShape XH df
|
|
save 'cyrsha.upright'
|
|
|
|
turned 'cyrsha.italic' null 'm' [DivFrame para.diversityM 3].middle (XH / 2)
|
|
italic-variant 'cyrsha' 0x448
|
|
|
|
define [CyrShchaShape top df] : glyph-construction
|
|
include : CyrShaShape top df
|
|
#eject-contour 'serifRB'
|
|
include : CyrDescender df.rightSB 0.05
|
|
|
|
sketch # cyrShcha
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrShchaShape CAP df
|
|
|
|
save 'cyrShcha' 0x429
|
|
|
|
sketch # cyrshcha.upright
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrShchaShape XH df
|
|
save 'cyrshcha.upright'
|
|
|
|
sketch # cyrshcha.italic
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include glyphs.'cyrsha.italic'
|
|
include : CyrDescender df.rightSB 0.05
|
|
save 'cyrshcha.italic'
|
|
|
|
italic-variant 'cyrshcha' 0x449
|
|
|
|
# Serbian pe and te
|
|
sketch # cyrte.SRB
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include glyphs.'cyrsha.italic' AS_BASE
|
|
include glyphs.macronAbove
|
|
save 'cyrte.SRB'
|
|
|
|
italic-variant 'cyrte' 0x442
|
|
|
|
|
|
define [CyrCheShape top _barp] : glyph-construction
|
|
local bar : top * [fallback _barp 0.5]
|
|
include : VBarRight RIGHTSB 0 top
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB top [heading DOWNWARD]
|
|
curl SB (bar + SMOOTHB - HALFSTROKE)
|
|
arcvh
|
|
flat MIDDLE (bar - HALFSTROKE)
|
|
curl (RIGHTSB - 1) (bar - HALFSTROKE) [heading RIGHTWARD]
|
|
if SLAB : begin
|
|
include : CenterTopSerif (RIGHTSB - HALFSTROKE * HVCONTRAST) top JUT
|
|
include : CenterTopSerif (SB + HALFSTROKE * HVCONTRAST) top JUT
|
|
include : CenterBottomSerif (RIGHTSB - HALFSTROKE * HVCONTRAST) 0 JUT
|
|
|
|
sketch # cyrChe
|
|
include MarkSet.capital
|
|
include : CyrCheShape CAP [if SLAB 0.45 0.35]
|
|
save 'cyrChe' 0x427
|
|
composite glyphs.cyrChe [CyrDescender RIGHTSB] [into-unicode 0x4B6]
|
|
|
|
sketch # cyrche
|
|
include MarkSet.e
|
|
include : CyrCheShape XH [if SLAB 0.45 0.4]
|
|
save 'cyrche' 0x447
|
|
composite glyphs.cyrche [CyrDescender RIGHTSB] [into-unicode 0x4B7]
|
|
|
|
turned 'cyrShha' 0x4BA 'cyrChe' MIDDLE (CAP / 2)
|
|
|
|
sketch # cyrChevbar
|
|
include glyphs.cyrChe AS_BASE
|
|
local yc (CAP * [if SLAB 0.45 0.35] + STROKE * 0.1)
|
|
include : VBar MIDDLE (yc + LONGJUT * 0.8) (yc - LONGJUT * 0.8) OVERLAYSTROKE
|
|
save 'cyrChevbar' 0x4B8
|
|
|
|
sketch # cyrchevbar
|
|
include glyphs.cyrche AS_BASE
|
|
local yc (XH * [if SLAB 0.45 0.35] + STROKE * 0.1)
|
|
include : VBar MIDDLE (yc + LONGJUT * 0.8) (yc - LONGJUT * 0.8) OVERLAYSTROKE
|
|
save 'cyrchevbar' 0x4B9
|
|
|
|
|
|
define [CyrYuShape top xtop sma smb div] : glyph-construction
|
|
local df : DivFrame div 3
|
|
local xm : barmixL df.leftSB df.rightSB (df.mvs * HVCONTRAST) [linreg 18 0.4 126 0.45 STROKE]
|
|
include : VBarLeft df.leftSB 0 xtop df.mvs
|
|
include : OShape top 0 xm df.rightSB df.mvs (sma * 0.7 * df.div) (smb * 0.7 * df.div)
|
|
include : HBar (df.leftSB + 1) xm (top / 2)
|
|
|
|
if SLAB : begin
|
|
include : CenterTopSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) top (JUT * 0.75)
|
|
include : CenterBottomSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) 0 (JUT * 0.75)
|
|
|
|
sketch # cyrYu
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrYuShape CAP CAP SMOOTHA SMOOTHB df.div
|
|
save 'cyrYu' 0x42E
|
|
|
|
sketch # cyryu
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrYuShape XH XH SMALLSMOOTHA SMALLSMOOTHB df.div
|
|
save 'cyryu' 0x44E
|
|
|
|
sketch # cyryu.BGR
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : CyrYuShape XH CAP SMALLSMOOTHA SMALLSMOOTHB df.div
|
|
save 'cyryu.BGR'
|
|
|
|
|
|
define [CyrLjeShape top df] : glyph-construction
|
|
local rightSB : df.width - df.leftSB
|
|
local l : df.leftSB + O
|
|
local r : rightSB - O
|
|
local middle : df.width / 2
|
|
local xlefttop : mix l r 0.075
|
|
local jut : JUT * 0.72
|
|
set-width df.width
|
|
include : LegShape
|
|
ztop -- (xlefttop <> top)
|
|
zbot -- ([mix l 0 [if SLAB 1 0.75]] <> 0)
|
|
xb -- [mix l r 0.025]
|
|
fine -- MVERTSTROKE
|
|
include : CyrYeriShape top (middle - MVERTSTROKE / 2 * HVCONTRAST) (r - O) MVERTSTROKE jut
|
|
include : HBarTop xlefttop middle top
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif xlefttop top (jut - MVERTSTROKE / 2 * HVCONTRAST)
|
|
|
|
sketch # cyrLje
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrLjeShape CAP df
|
|
save 'cyrLje' 0x409
|
|
|
|
sketch # cyrlje
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrLjeShape XH df
|
|
save 'cyrlje' 0x459
|
|
|
|
define [CyrNjeShape top df] : glyph-construction
|
|
local rightSB : df.width - df.leftSB
|
|
local xlefttop : mix df.leftSB df.rightSB 0.075
|
|
local jut : JUT * 0.72
|
|
local l : df.leftSB + O
|
|
local r : rightSB - O
|
|
local middle : df.width / 2
|
|
set-width df.width
|
|
include : VBarLeft l 0 top MVERTSTROKE
|
|
include : CyrYeriShape top (middle - MVERTSTROKE / 2 * HVCONTRAST) (r - O) MVERTSTROKE jut
|
|
include : HBar (df.leftSB + MVERTSTROKE * 0.1) middle (top / 2)
|
|
if SLAB : begin
|
|
include : CenterTopSerif (l + MVERTSTROKE / 2 * HVCONTRAST) top jut
|
|
include : CenterBottomSerif (l + MVERTSTROKE / 2 * HVCONTRAST) 0 jut
|
|
|
|
sketch # cyrNje
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : CyrNjeShape CAP df
|
|
save 'cyrNje' 0x40A
|
|
|
|
sketch # cyrnje
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : CyrNjeShape XH df
|
|
save 'cyrnje' 0x45A
|
|
|
|
|
|
sketch # cyrTshe
|
|
include MarkSet.capital
|
|
|
|
local left : [mix SB RIGHTSB 0.15] + OX
|
|
local right : RIGHTSB - OX
|
|
|
|
include : nShoulder
|
|
left -- (left + STROKE * HVCONTRAST)
|
|
right -- right
|
|
include : VBarLeft left 0 CAP
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (SB + OX) CAP
|
|
curl [mix left RIGHTSB 0.475] CAP
|
|
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (left + HVCONTRAST * HALFSTROKE) 0 JUT
|
|
include : CenterBottomSerif (right - HVCONTRAST * HALFSTROKE) 0 JUT
|
|
|
|
save 'cyrTshe' 0x40B
|
|
|
|
sketch # cyrDje
|
|
include MarkSet.capital
|
|
|
|
local left : [mix SB RIGHTSB 0.15] + OX
|
|
local right: RIGHTSB - OX * 1.5
|
|
|
|
include : nShoulder
|
|
left -- (left + STROKE * HVCONTRAST)
|
|
right -- right
|
|
top -- XH
|
|
bottom -- (HOOK + HALFSTROKE + O)
|
|
sma -- SMOOTHA
|
|
smb -- SMOOTHB
|
|
include : VBarLeft left 0 CAP
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (SB + OX) CAP
|
|
curl [mix left RIGHTSB 0.475] CAP
|
|
include : VerticalHook (right - HALFSTROKE * HVCONTRAST) (HOOK + HALFSTROKE + O) [Math.max ((left - right) / 2 + HALFSTROKE) (-HOOK * 1.2)] HOOK
|
|
|
|
if SLAB : begin
|
|
include : LeftwardBottomSerif left 0 SIDEJUT
|
|
|
|
save 'cyrDje' 0x402
|
|
|
|
sketch # cyrdje
|
|
include MarkSet.if
|
|
include glyphs.cyrtshe
|
|
eject-contour 'serifRB'
|
|
include : VerticalHook (RIGHTSB - HALFSTROKE * HVCONTRAST) 0 (-HOOK * 1.2) HOOK
|
|
save 'cyrdje' 0x452
|
|
|
|
###########################################################################################
|
|
# UNIFIED LETTERFORMS : OTHER LATIN
|
|
###########################################################################################
|
|
do
|
|
local ymiddle : [mix 0 CAP 0.5] - HALFSTROKE
|
|
local ymiddleCap : [mix 0 CAP 0.54] - HALFSTROKE
|
|
local xmiddle : RIGHTSB - ymiddle / 2 - STROKE * 0.75
|
|
local xmiddleBot : RIGHTSB - ymiddle / 2 - STROKE * 0.75
|
|
local xfinal : Math.min
|
|
xmiddle - 1 - STROKE * TANSLANT
|
|
Math.max (SB + STROKE * 2) [mix SB RIGHTSB (1 / 4)]
|
|
sketch # eszet
|
|
set-width WIDTH
|
|
include MarkSet.if
|
|
local l : SB * 1
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 ([mix SB RIGHTSB 0.75] + HALFSTROKE * HVCONTRAST) (CAP - HOOK)
|
|
hookstart (CAP - O)
|
|
flat l XH
|
|
curl l 0 [heading DOWNWARD]
|
|
local t : mix 0 CAP 0.7
|
|
local tm : [mix DESCENDER t 0.625] + HALFSTROKE
|
|
local tl : [mix l RIGHTSB 0.35] + HALFSTROKE * HVCONTRAST
|
|
include : HBarTop (l + 1) (RIGHTSB - HALFSTROKE * 1.2 - OX) t
|
|
include : dispiro
|
|
widths.rhs
|
|
flat tl tm [heading RIGHTWARD]
|
|
curl (tl + 1) tm [heading RIGHTWARD]
|
|
g2 (RIGHTSB - OX * 1.5) [mix DESCENDER tm 0.70]
|
|
g2 (RIGHTSB - OX * 1.5) [mix DESCENDER tm 0.67]
|
|
alsothru 0.5 0.75
|
|
g4 [mix SB RIGHTSB 0.35] DESCENDER
|
|
include : dispiro
|
|
widths.center (STROKE * 1.1)
|
|
corner tl (tm - STROKE) [heading UPWARD]
|
|
corner (RIGHTSB - HALFSTROKE * 1.2 - OX) t [heading UPWARD]
|
|
piecewise
|
|
para.isItalic : include : VerticalHook (l + HALFSTROKE * HVCONTRAST) 0 (-HOOK * 1.2) HOOK
|
|
SLAB : include : LeftwardBottomSerif SB 0 SIDEJUT
|
|
save 'eszet.traditional'
|
|
|
|
sketch # eszet.sulzbacher
|
|
include MarkSet.capital
|
|
include : dispiro
|
|
widths.rhs
|
|
flat SB 0 [heading UPWARD]
|
|
curl SB XH
|
|
arcvh
|
|
g4 (MIDDLE + O) (CAP - O)
|
|
archv
|
|
g4 (RIGHTSB + O * 2) [mix CAP ymiddle 0.47]
|
|
g4.left.end xmiddle ymiddle [heading LEFTWARD]
|
|
include : dispiro
|
|
widths.rhs
|
|
g4.right.start xmiddle (ymiddle + STROKE) [heading RIGHTWARD]
|
|
archv
|
|
g4 (RIGHTSB - O) [mix 0 (ymiddle + STROKE) 0.5]
|
|
arcvh
|
|
flat xmiddleBot 0
|
|
curl xfinal 0 [heading LEFTWARD]
|
|
piecewise
|
|
para.isItalic : include : VerticalHook (SB + HALFSTROKE * HVCONTRAST) 0 (-HOOK * 1.2) HOOK
|
|
SLAB : include : LeftwardBottomSerif SB 0 SIDEJUT
|
|
save 'eszet.sulzbacher'
|
|
|
|
select-variant 'eszet' 0xDF
|
|
|
|
sketch # Eszet
|
|
include MarkSet.capital
|
|
local rightTopX : RIGHTSB + O * 4
|
|
include : dispiro
|
|
widths.lhs
|
|
flat rightTopX CAP
|
|
curl MIDDLE CAP
|
|
archv
|
|
flat SB XH
|
|
curl SB 0 [heading DOWNWARD]
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 xmiddle (ymiddleCap + STROKE) [heading RIGHTWARD]
|
|
archv
|
|
g4 (RIGHTSB - O * 2) [mix 0 (ymiddleCap + STROKE) 0.5]
|
|
arcvh
|
|
flat xmiddleBot 0
|
|
curl xfinal 0 [heading LEFTWARD]
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 rightTopX (CAP - STROKE)
|
|
g4 xmiddle (ymiddleCap + STROKE) [widths STROKE 0]
|
|
if SLAB : include : LeftwardBottomSerif SB 0 SIDEJUT
|
|
save 'Eszet' 0x1E9E
|
|
|
|
|
|
sketch # AE
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
|
|
local eleft : df.middle - df.mvs * 0.25
|
|
local turn : XH * 0.1
|
|
|
|
# A half
|
|
include : dispiro
|
|
widths.rhs df.mvs
|
|
flat df.leftSB 0 [heading UPWARD]
|
|
curl df.leftSB (CAP * 0.1) [heading UPWARD]
|
|
quadcontrols 0 0.3 6 unimportant
|
|
g4 (eleft - HALFSTROKE) CAP [widths.rhs (df.mvs * 0.8)]
|
|
|
|
start-from (eleft - HALFSTROKE) CAP
|
|
line-to eleft CAP
|
|
line-to eleft (CAP - df.mvs)
|
|
include : HBarTop ([mix df.leftSB (eleft - HALFSTROKE) (1/6)] + df.mvs * 0.5 * HVCONTRAST) (eleft + df.mvs / 2) (XH / 2) df.mvs
|
|
|
|
# E half
|
|
include : VBarLeft eleft 0 CAP df.mvs
|
|
include : HBarTop (eleft - O) df.rightSB CAP
|
|
include : HBar (eleft - O) (df.rightSB - df.mvs / 4) (CAP * 0.54)
|
|
include : HBarBottom (eleft - O) df.rightSB 0
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) 0 JUT df.mvs
|
|
include : DownwardRightSerif df.rightSB CAP VJUT df.mvs
|
|
include : UpwardRightSerif df.rightSB 0 VJUT df.mvs
|
|
save 'AE' 0xC6
|
|
save 'cyrAE' 0x4D4
|
|
|
|
define [OEShape top df] : glyph-construction
|
|
local eleft df.middle
|
|
|
|
# O half
|
|
|
|
include : dispiro
|
|
widths.lhs df.mvs 0
|
|
straight.left.start eleft top [heading LEFTWARD]
|
|
archv
|
|
flat df.leftSB (top - SMOOTHA)
|
|
curl df.leftSB (SMOOTHB)
|
|
arcvh
|
|
straight.right.end eleft 0 [heading RIGHTWARD]
|
|
|
|
# E half
|
|
include : VBarLeft eleft 0 top df.mvs
|
|
include : HBarTop (eleft - O) df.rightSB top
|
|
include : HBar (eleft - O) (df.rightSB - df.mvs / 4) (top * 0.54)
|
|
include : HBarBottom (eleft - O) df.rightSB 0
|
|
|
|
if SLAB : begin
|
|
include : DownwardRightSerif df.rightSB top VJUT df.mvs
|
|
include : UpwardRightSerif df.rightSB 0 VJUT df.mvs
|
|
|
|
sketch # OE
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : OEShape CAP df
|
|
save 'OE' 0x152
|
|
|
|
sketch # smcpOE
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : OEShape XH df
|
|
save 'smcpOE' 0x276
|
|
|
|
define [aeepart df] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 3 XH df.div
|
|
local eLeft : df.middle - stroke / 2 * HVCONTRAST + 0.1
|
|
local eMiddle : [mix eLeft (df.rightSB - OX * 2) 0.5] - stroke * TANSLANT
|
|
local barbottom (XH * EBARPOS - stroke / 2)
|
|
|
|
local sma : SMALLSMOOTHA * 0.6 * df.div
|
|
local smb : SMALLSMOOTHB * 0.6 * df.div
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
flat (df.rightSB - OX * 2) barbottom [heading UPWARD]
|
|
curl (df.rightSB - OX * 2) (XH - smb)
|
|
arcvh
|
|
g4 eMiddle XO
|
|
archv
|
|
flat eLeft (XH - sma)
|
|
curl eLeft smb
|
|
hookend O (tight -- true) (sw -- stroke)
|
|
g4 (df.rightSB - OX * 2) (AHOOK + stroke * TANSLANT) [heading UPWARD]
|
|
include : HBarBottom (eLeft + stroke / 2) (df.rightSB - OX * 2 - stroke / 2) barbottom stroke
|
|
|
|
define [aeapart df] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 3 XH df.div
|
|
local bartop (XH * OVERLAYPOS * 1.02 + stroke / 2)
|
|
local abarRight : df.middle + stroke / 2 * HVCONTRAST - 0.1
|
|
local lowmiddle : mix (df.leftSB + OX * 2) abarRight 0.5
|
|
local barsmooth : mix df.leftSB abarRight 0.7
|
|
|
|
local sma : SMALLSMOOTHA * 0.6 * df.div
|
|
local smb : SMALLSMOOTHB * 0.6 * df.div
|
|
|
|
include : dispiro
|
|
widths.rhs stroke
|
|
g4 (df.leftSB + OX) (XH - AHOOK - stroke * TANSLANT) [heading UPWARD]
|
|
hookstart XO (tight -- true) (sw -- stroke)
|
|
flat abarRight (XH - smb)
|
|
curl abarRight smb
|
|
arcvh
|
|
g4 lowmiddle O [heading LEFTWARD]
|
|
archv
|
|
g4 (df.leftSB + OX * 2) [mix 0 bartop 0.45]
|
|
arcvh
|
|
flat barsmooth bartop
|
|
curl (abarRight - 1) bartop [heading RIGHTWARD]
|
|
|
|
define [oeopart df] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 3 XH df.div
|
|
local abarRight : df.middle + stroke / 2 * HVCONTRAST
|
|
include : OShape XH 0 (df.leftSB + OX) (abarRight + OX) stroke (SMALLSMOOTHA * 0.6 * df.div) (SMALLSMOOTHB * 0.6 * df.div)
|
|
|
|
sketch # ae
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : aeepart df
|
|
include : aeapart df
|
|
save 'ae' 0xE6
|
|
save 'cyrae' 0x4D5
|
|
turned nothing 0x1D02 'ae' [DivFrame para.diversityM].middle (XH / 2)
|
|
|
|
sketch # oe
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : aeepart df
|
|
include : oeopart df
|
|
save 'oe' 0x153
|
|
turned nothing 0x1D14 'oe' [DivFrame para.diversityM].middle (XH / 2)
|
|
|
|
sketch # db
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : oeopart df
|
|
include : FlipAround df.middle (XH / 2)
|
|
include : oeopart df
|
|
include : VBar df.middle (XH / 2) CAP MVERTSTROKE
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (df.middle - MVERTSTROKE / 2 * HVCONTRAST) CAP SIDEJUT
|
|
|
|
save 'db' 0x238
|
|
|
|
sketch # qp
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.p
|
|
include : oeopart df
|
|
include : FlipAround df.middle (XH / 2)
|
|
include : oeopart df
|
|
include : VBar df.middle DESCENDER (XH / 2) MVERTSTROKE
|
|
if SLAB : begin
|
|
include : CenterBottomSerif df.middle DESCENDER JUT
|
|
|
|
save 'qp' 0x239
|
|
|
|
sketch # OU
|
|
include MarkSet.capital
|
|
include : OShape (CAP * BARPOS + HALFSTROKE) 0 SB RIGHTSB nothing SMOOTHA SMOOTHB
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB CAP [heading DOWNWARD]
|
|
curl SB (CAP * BARPOS - O - HALFSTROKE + SMOOTHB)
|
|
arcvh
|
|
g4 (MIDDLE + CORRECTION_OMIDS) (CAP * BARPOS - O - HALFSTROKE + (STROKE * (1 - CTHIN))) [widths.lhs (STROKE * CTHIN)]
|
|
archv
|
|
flat RIGHTSB (CAP * BARPOS - O - HALFSTROKE + SMOOTHA) [widths.lhs]
|
|
curl RIGHTSB CAP [heading UPWARD]
|
|
|
|
save 'OU' 0x222
|
|
|
|
sketch # ou
|
|
include MarkSet.b
|
|
local bar : linreg 18 (XH * 0.9) 108 XH STROKE
|
|
include : OShape bar 0 SB RIGHTSB
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB CAP [heading DOWNWARD]
|
|
curl SB (bar - O - STROKE + SMOOTHB)
|
|
arcvh
|
|
g4 (MIDDLE + CORRECTION_OMIDS) (bar - O - STROKE + (STROKE * (1 - CTHIN))) [widths.lhs (STROKE * CTHIN)]
|
|
archv
|
|
flat RIGHTSB (bar - O - STROKE + SMOOTHA) [widths.lhs]
|
|
curl RIGHTSB CAP [heading UPWARD]
|
|
|
|
save 'ou' 0x223
|
|
|
|
sketch # IJ
|
|
include MarkSet.capital
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.'I.straight'
|
|
apply-transform : Translate (SB - MIDDLE + HALFSTROKE * HVCONTRAST) 0
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.'J.shorthook'
|
|
apply-transform : Translate JBALANCE2 0
|
|
|
|
save 'IJ' 0x132
|
|
|
|
sketch # ij
|
|
include MarkSet.if
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.'dotlessi.straight' AS_BASE
|
|
include glyphs.dotAbove
|
|
apply-transform : Translate (SB * 1.5 - MIDDLE + HALFSTROKE * HVCONTRAST) 0
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.'dotlessj.straight' AS_BASE
|
|
include glyphs.dotAbove
|
|
apply-transform : Translate (RIGHTSB - SB * 0.5 - MIDDLE - JBALANCE - HALFSTROKE * HVCONTRAST) 0
|
|
save 'ij' 0x133
|
|
|
|
|
|
define [EzhShape top bot pleft pright hookless] : glyph-construction
|
|
local cor : 1.2 * HVCONTRAST
|
|
local yMidBar : mix bot top 0.6
|
|
local ezhLeft : mix SB RIGHTSB [fallback pleft 0.2]
|
|
local ezhRight : mix SB RIGHTSB [fallback pright 0.925]
|
|
|
|
include : HBarTop SB ezhRight top
|
|
|
|
start-from ezhLeft yMidBar
|
|
line-to (ezhLeft + STROKE * cor) (yMidBar - HALFSTROKE)
|
|
line-to (ezhLeft + STROKE * cor) yMidBar
|
|
line-to ezhRight (top - STROKE)
|
|
line-to (ezhRight - STROKE * cor) (top - STROKE)
|
|
reverse-last
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
flat ezhLeft yMidBar [heading RIGHTWARD]
|
|
curl (MIDDLE - CORRECTION_OMIDS) yMidBar
|
|
archv
|
|
if hookless
|
|
: then : list
|
|
g4 (RIGHTSB - OX) [mix yMidBar bot hookless] [heading DOWNWARD]
|
|
g4 (RIGHTSB - OX) ([mix yMidBar bot hookless] - 1) [heading DOWNWARD]
|
|
: else : list
|
|
g4 (RIGHTSB - OX) [mix yMidBar bot : SMALLSMOOTHB / (SMALLSMOOTHA + SMALLSMOOTHB)]
|
|
hookend bot
|
|
g4 SB (bot + HOOK * (top - bot) / [fallback para.cap0 CAP])
|
|
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif SB top VJUT
|
|
|
|
define [RevEzhShape top bot pleft pright hookless] : glyph-construction
|
|
local cor : 1.2 * HVCONTRAST
|
|
local yMidBar : mix bot top 0.6
|
|
local ezhRight : mix RIGHTSB SB [fallback pleft 0.2]
|
|
local ezhLeft : mix RIGHTSB SB [fallback pright 0.925]
|
|
include : HBarTop ezhLeft RIGHTSB top
|
|
|
|
start-from ezhRight yMidBar
|
|
line-to (ezhRight - STROKE * cor) (yMidBar - HALFSTROKE)
|
|
line-to (ezhRight - STROKE * cor) yMidBar
|
|
line-to ezhLeft (top - STROKE)
|
|
line-to (ezhLeft + STROKE * cor) (top - STROKE)
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
flat ezhRight yMidBar [heading LEFTWARD]
|
|
curl (MIDDLE + CORRECTION_OMIDS) yMidBar
|
|
archv
|
|
g4 (SB + OX) [mix yMidBar bot (SMALLSMOOTHA / (SMALLSMOOTHA + SMALLSMOOTHB))] [if [not hookless] important [heading DOWNWARD]]
|
|
if hookless {} : list
|
|
hookend bot
|
|
g4 RIGHTSB (bot + HOOK * ((top - bot) / CAP))
|
|
if SLAB : begin
|
|
include : DownwardRightSerif RIGHTSB top VJUT
|
|
|
|
sketch # Ezh
|
|
set-width WIDTH
|
|
include MarkSet.capital
|
|
include : EzhShape CAP 0
|
|
save 'Ezh' 0x1B7
|
|
save 'cyrEzh' 0x4E0
|
|
|
|
sketch # ezh
|
|
set-width WIDTH
|
|
include MarkSet.p
|
|
include : EzhShape XH DESCENDER
|
|
save 'ezh' 0x292
|
|
save 'cyrezh' 0x4E1
|
|
|
|
sketch # revEzh
|
|
include MarkSet.capital
|
|
include : RevEzhShape CAP 0
|
|
|
|
save 'revEzh' 0x1B8
|
|
|
|
sketch # revezh
|
|
include MarkSet.p
|
|
include : RevEzhShape XH DESCENDER
|
|
|
|
save 'revezh' 0x1B9
|
|
|
|
sketch # lyogh
|
|
include MarkSet.if
|
|
include : EzhShape XH DESCENDER 0.4
|
|
include : VBarLeft SB (XH * 0.1) CAP
|
|
|
|
save 'lyogh' 0x26E
|
|
|
|
sketch # ezhtail
|
|
local b : mix DESCENDER XH 0.25
|
|
include : EzhShape XH b nothing nothing 0.5
|
|
local y : mix [mix b XH 0.6] b 0.5
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 (RIGHTSB - OX) y [heading DOWNWARD]
|
|
g4 (RIGHTSB - OX) (y - 1) [heading DOWNWARD]
|
|
arcvh
|
|
flat [mix SB RIGHTSB 0.45] b
|
|
curl [mix SB RIGHTSB 0.4] b
|
|
archv
|
|
g4 (SB + STROKE * HVCONTRAST) [mix (DESCENDER + STROKE) b 0.5]
|
|
arcvh
|
|
flat [mix SB RIGHTSB 0.4] (DESCENDER + STROKE)
|
|
curl RIGHTSB (DESCENDER + STROKE)
|
|
|
|
save 'ezhtail' 0x1BA
|
|
|
|
sketch # ezhcurlytail
|
|
include MarkSet.e
|
|
local p (SMALLSMOOTHB / (SMALLSMOOTHA + SMALLSMOOTHB))
|
|
include : EzhShape XH DESCENDER nothing nothing p
|
|
local fine : adviceBlackness 3
|
|
local rinner : (XH * 0.4 - fine * 1.5) / 2
|
|
local m1 : RIGHTSB - STROKE * HVCONTRAST - OX
|
|
local x2 : RIGHTSB - HALFSTROKE
|
|
local y2 DESCENDER
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 m1 [mix [mix DESCENDER XH 0.6] DESCENDER p] [heading DOWNWARD]
|
|
g4 m1 ([mix [mix DESCENDER XH 0.6] DESCENDER p] - 1) [heading DOWNWARD]
|
|
CurlyTail fine rinner m1 DESCENDER SB x2 y2
|
|
save 'ezhcurlytail' 0x293
|
|
|
|
|
|
sketch # glottalstop
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 SB (CAP - HOOK)
|
|
hookstart CAPO
|
|
g4 RIGHTSB (CAP - [adviceGlottalStopSmooth CAP 1])
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE + HALFSTROKE * HVCONTRAST) (XH * 0.3)
|
|
curl (MIDDLE + HALFSTROKE * HVCONTRAST) 0 [heading DOWNWARD]
|
|
if SLAB : begin
|
|
include : CenterBottomSerif MIDDLE 0 JUT
|
|
|
|
save 'glottalstop' 0x294
|
|
save 'capglottalstop' 0x241
|
|
|
|
sketch # revglottalstop
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 RIGHTSB (CAP - HOOK)
|
|
hookstart CAPO
|
|
g4 SB (CAP - [adviceGlottalStopSmooth CAP (-1)])
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE - HALFSTROKE * HVCONTRAST) (XH * 0.3)
|
|
curl (MIDDLE - HALFSTROKE * HVCONTRAST) 0 [heading DOWNWARD]
|
|
if SLAB : begin
|
|
include : CenterBottomSerif MIDDLE 0 JUT
|
|
save 'revglottalstop' 0x295
|
|
|
|
sketch # smallglottalstop
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 SB (XH - HOOK)
|
|
hookstart XO
|
|
g4 RIGHTSB (XH - [adviceGlottalStopSmooth XH 1])
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE + HALFSTROKE * HVCONTRAST) (XH * 0.15)
|
|
curl (MIDDLE + HALFSTROKE * HVCONTRAST) 0 [heading DOWNWARD]
|
|
if SLAB : begin
|
|
include : CenterBottomSerif MIDDLE 0 JUT
|
|
|
|
save 'smallglottalstop' 0x242
|
|
|
|
sketch # invglottalstopbar
|
|
include MarkSet.e
|
|
local smooth : adviceGlottalStopSmooth XH (-1 - TANSLANT * (15 - (WIDTH / 500) * 12) * [clamp 0 1 : linreg 126 1 135 0.5 STROKE])
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 RIGHTSB (XH - HOOK)
|
|
hookstart XO
|
|
g4.down.mid SB (XH - smooth)
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE - HALFSTROKE * HVCONTRAST) (XH * 0.15)
|
|
curl (MIDDLE - HALFSTROKE * HVCONTRAST) 0 [heading DOWNWARD]
|
|
include : HOverlayBar (MIDDLE - LONGJUT * 0.6) (MIDDLE + LONGJUT * 0.6) (XH * 0.25)
|
|
include : FlipAround MIDDLE (XH / 2)
|
|
|
|
save 'invglottalstopbar' 0x1BE
|
|
|
|
sketch # fineglottalstop
|
|
include MarkSet.b
|
|
local fine : markHalfStroke * 2
|
|
include : dispiro
|
|
widths.rhs fine
|
|
g4 SB (CAP - HOOK)
|
|
hookstart CAPO
|
|
g4 RIGHTSB (CAP - [adviceGlottalStopSmooth CAP 1])
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE + fine / 2 * HVCONTRAST) (XH * 0.3)
|
|
curl (MIDDLE + fine / 2 * HVCONTRAST) 0 [heading DOWNWARD]
|
|
if SLAB : begin
|
|
include : CenterBottomSerif MIDDLE 0 JUT fine
|
|
|
|
save 'fineglottalstop'
|
|
|
|
sketch # finerevglottalstop
|
|
include MarkSet.b
|
|
local fine : markHalfStroke * 2
|
|
include : dispiro
|
|
widths.lhs fine
|
|
g4 RIGHTSB (CAP - HOOK)
|
|
hookstart CAPO
|
|
g4 SB (CAP - [adviceGlottalStopSmooth CAP (-1)])
|
|
alsothru 0.5 0.5 important
|
|
flat (MIDDLE - fine / 2 * HVCONTRAST) (XH * 0.3)
|
|
curl (MIDDLE - fine / 2 * HVCONTRAST) 0 [heading DOWNWARD]
|
|
if SLAB : begin
|
|
include : CenterBottomSerif MIDDLE 0 JUT fine
|
|
save 'finerevglottalstop'
|
|
|
|
turned 'invglottalstop' 0x296 'revglottalstop' MIDDLE (CAP / 2)
|
|
|
|
sketch # glottalstopbar
|
|
include glyphs.glottalstop AS_BASE
|
|
include : HOverlayBar (MIDDLE - LONGJUT * 0.6) (MIDDLE + LONGJUT * 0.6) (CAP * 0.25)
|
|
|
|
save 'glottalstopbar' 0x2A1
|
|
|
|
sketch # revglottalstopbar
|
|
include glyphs.revglottalstop AS_BASE
|
|
include : HOverlayBar (MIDDLE - LONGJUT * 0.6) (MIDDLE + LONGJUT * 0.6) (CAP * 0.25)
|
|
save 'revglottalstopbar' 0x2A2
|
|
|
|
|
|
sketch
|
|
include MarkSet.b
|
|
|
|
include : OShape (CAP * 0.6) 0 SB RIGHTSB
|
|
local ymiddlea : (CAP * 0.6 + SMALLSMOOTHA - SMALLSMOOTHB) / 2
|
|
include : dispiro
|
|
widths.lhs
|
|
g4.up.start (RIGHTSB - OX) ymiddlea
|
|
quadcontrols 0 0.8
|
|
g4 (SB + STROKE * 1.1) CAP
|
|
|
|
include : dispiro
|
|
widths.center OVERLAYSTROKE
|
|
flat [mix SB RIGHTSB 0.1] [mix XH CAP (-0.1)]
|
|
curl [mix SB RIGHTSB 0.95] [mix XH CAP 0.3]
|
|
|
|
save 'eth' 0xF0
|
|
|
|
|
|
sketch # Thorn
|
|
set-width WIDTH
|
|
include MarkSet.capital
|
|
|
|
local bowlTop (CAP * 0.81)
|
|
local bowlBottom (CAP * 0.19)
|
|
|
|
local turn : mix bowlTop bowlBottom (SMOOTHB / (SMOOTHA + SMOOTHB))
|
|
local turnRadius : (bowlTop - bowlBottom) / 2
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (SB * 1.25 + 1) bowlTop [heading RIGHTWARD]
|
|
curl (RIGHTSB - turnRadius - CORRECTION_OMIDS) bowlTop
|
|
archv
|
|
g4 (RIGHTSB - O) turn
|
|
arcvh
|
|
flat (RIGHTSB - turnRadius + CORRECTION_OMIDS) bowlBottom
|
|
curl (SB * 1.25 + 1) bowlBottom [heading LEFTWARD]
|
|
|
|
include : VBarLeft (SB * 1.25) 0 CAP
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (SB * 1.25 + HALFSTROKE * HVCONTRAST) 0 JUT
|
|
include : CenterTopSerif (SB * 1.25 + HALFSTROKE * HVCONTRAST) CAP JUT
|
|
|
|
save 'Thorn' 0xDE
|
|
save 'Sho' 0x3F7
|
|
|
|
sketch # thorn
|
|
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.b
|
|
eject-contour 'serifLB'
|
|
include : create-glyph : glyph-construction
|
|
include glyphs.p
|
|
eject-contour 'bowl'
|
|
eject-contour 'serifLT'
|
|
include MarkSet.if
|
|
|
|
save 'thorn' 0xFE
|
|
save 'sho' 0x3F8
|
|
|
|
|
|
sketch # Hwair
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : VBarLeft df.leftSB 0 CAP df.mvs
|
|
include : HBar SB df.middle (CAP / 2)
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat (df.middle - df.mvs * 0.5 * HVCONTRAST) CAP [heading DOWNWARD]
|
|
curl (df.middle - df.mvs * 0.5 * HVCONTRAST) (SMALLSMOOTHB * 0.6 * df.div)
|
|
arcvh
|
|
g4 [mix (df.middle - df.mvs * 0.5 * HVCONTRAST) df.rightSB 0.5] O [heading RIGHTWARD]
|
|
archv
|
|
flat df.rightSB (SMALLSMOOTHA * 0.6 * df.div)
|
|
curl df.rightSB XH [heading UPWARD]
|
|
if SLAB : begin
|
|
local jut : JUT * 0.75
|
|
include : CenterTopSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) CAP jut
|
|
include : CenterBottomSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) 0 jut
|
|
include : CenterTopSerif df.middle CAP jut
|
|
|
|
save 'Hwair' 0x1F6
|
|
|
|
sketch # hwair
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : VBarLeft df.leftSB 0 CAP df.mvs
|
|
include : dispiro
|
|
nShoulderKnots (df.leftSB + df.mvs * HVCONTRAST) (df.middle + df.mvs * 0.5 * HVCONTRAST) (df.mvs * 0.4) nothing (XH * 0.51) (SMALLSMOOTHA * 0.6 * df.div) (SMALLSMOOTHB * 0.6 * df.div) df.mvs
|
|
flat (df.middle + df.mvs * 0.5 * HVCONTRAST) (XH * 0.5) [heading DOWNWARD]
|
|
curl (df.middle + df.mvs * 0.5 * HVCONTRAST) (SMALLSMOOTHB * 0.6 * df.div)
|
|
arcvh
|
|
g4 [mix (df.middle - df.mvs * 0.5 * HVCONTRAST) df.rightSB 0.5] O [widths.heading df.mvs 0 RIGHTWARD]
|
|
archv
|
|
flat df.rightSB (SMALLSMOOTHA * 0.6 * df.div)
|
|
curl df.rightSB XH [heading UPWARD]
|
|
if SLAB : begin
|
|
local jut : JUT * 0.75
|
|
include : LeftwardTopSerif df.leftSB CAP (jut - df.mvs / 2 * HVCONTRAST)
|
|
if (!para.isItalic) : begin
|
|
include : CenterBottomSerif (df.leftSB + df.mvs / 2 * HVCONTRAST) 0 jut
|
|
tag-contour 'serifLB'
|
|
save 'hwair' 0x195
|
|
|
|
|
|
sketch # Gha
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
local abarRight : df.middle + df.mvs / 2 * HVCONTRAST
|
|
include : OShape CAP 0 df.leftSB abarRight df.mvs (SMALLSMOOTHA * df.div * 0.6) (SMALLSMOOTHB * df.div * 0.6)
|
|
include : VBarRight (df.rightSB - O) DESCENDER CAP df.mvs
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.middle (CAP - SMALLSMOOTHB * 0.6 * df.div) [heading RIGHTWARD]
|
|
curl (df.middle + 1) (CAP - SMALLSMOOTHB * 0.6 * df.div) [heading RIGHTWARD]
|
|
alsothru 0.5 0.15
|
|
g4 (df.rightSB - O - df.mvs * HVCONTRAST) CAP [widths 0 df.mvs]
|
|
save 'Gha' 0x1A2
|
|
|
|
sketch # gha
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.p
|
|
local abarRight : df.middle + df.mvs / 2 * HVCONTRAST
|
|
include : OShape XH 0 df.leftSB abarRight df.mvs (SMALLSMOOTHA * df.div * 0.6) (SMALLSMOOTHB * df.div * 0.6)
|
|
include : VBarRight (df.rightSB - O) DESCENDER XH df.mvs
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.middle (XH - SMALLSMOOTHB * 0.6 * df.div) [heading RIGHTWARD]
|
|
curl (df.middle + 1) (XH - SMALLSMOOTHB * 0.6 * df.div) [heading RIGHTWARD]
|
|
alsothru 0.5 0.15
|
|
g4 (df.rightSB - O - df.mvs * HVCONTRAST) XH [widths 0 df.mvs]
|
|
save 'gha' 0x1A3
|
|
|
|
|
|
define [WynnShape bot top] : glyph-construction
|
|
include : VBarLeft SB bot top
|
|
include : dispiro
|
|
widths.rhs (STROKE * CTHIN)
|
|
g4 (SB + HVCONTRAST * STROKE * (1 - CTHIN)) [mix bot top 0.8]
|
|
alsothru 0.55 0.85
|
|
g4 MIDDLE (top - O) [widths.heading 0 STROKE RIGHTWARD]
|
|
archv
|
|
g4 (RIGHTSB - O) [mix bot top 0.7]
|
|
alsothru 0.25 0.45
|
|
g4 (SB + STROKE * HVCONTRAST) [mix bot top 0.1]
|
|
|
|
sketch # Wynn
|
|
include MarkSet.capital
|
|
include : WynnShape 0 CAP
|
|
|
|
save 'Wynn' 0x1F7
|
|
|
|
sketch # wynn
|
|
include MarkSet.p
|
|
include : WynnShape DESCENDER XH
|
|
save 'wynn' 0x1BF
|
|
|
|
|
|
define [YoghShape top bot] : glyph-construction
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 SB (top - HOOK)
|
|
hookstart (top - O)
|
|
g4 RIGHTSB (top - SMOOTHB)
|
|
alsothruthem {{0.5 0.75}}
|
|
g4 ([mix SB RIGHTSB 0.1] + STROKE * 0.25) ([mix bot top 0.425] - HALFSTROKE)
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 [mix SB RIGHTSB 0.75] ([mix bot (top - SMOOTHB) 0.758] + HALFSTROKE)
|
|
g4 RIGHTSB ([mix bot (top - SMOOTHB) 0.475])
|
|
alsothruthem {{0.25 0.6} {0.5 0.81}}
|
|
g4 SB (bot + O)
|
|
|
|
sketch # Yogh
|
|
include MarkSet.capital
|
|
include : YoghShape CAP 0
|
|
|
|
save 'Yogh' 0x21C
|
|
|
|
sketch # yogh
|
|
include MarkSet.p
|
|
include : YoghShape XH DESCENDER
|
|
save 'yogh' 0x21D
|
|
|
|
define [RamsHornShape bottom top] : glyph-construction
|
|
local hf : [adviceBlackness 4] / 2
|
|
local d : hf * 2 + WIDTH * 0.05
|
|
|
|
include : dispiro
|
|
widths.center
|
|
g4 (SB + HALFSTROKE * HVCONTRAST + O) top [heading DOWNWARD]
|
|
quadcontrols 1 0.7 16
|
|
g4 (MIDDLE + d - hf) (bottom + d * (1 - TANSLANT * 0.5)) [widths hf hf]
|
|
arcvh
|
|
g4 (MIDDLE + CORRECTION_OMIDX * hf * 2) (bottom + hf)
|
|
archv
|
|
g4 (MIDDLE - d + hf) (bottom + d * (1 + TANSLANT * 0.5))
|
|
quadcontrols 0 0.3 16
|
|
g4 (RIGHTSB - HALFSTROKE * HVCONTRAST - O) top [widths.heading HALFSTROKE HALFSTROKE UPWARD]
|
|
|
|
sketch # latingamma
|
|
include MarkSet.p
|
|
include : RamsHornShape DESCENDER XH
|
|
|
|
save 'latingamma' 0x263
|
|
|
|
sketch # latinGamma
|
|
include MarkSet.if
|
|
include : RamsHornShape DESCENDER CAP
|
|
|
|
save 'latinGamma' 0x194
|
|
|
|
sketch # ramshorn
|
|
include MarkSet.e
|
|
include : RamsHornShape 0 XH
|
|
save 'ramshorn' 0x264
|
|
|
|
### Ayin
|
|
sketch # latinayin
|
|
include MarkSet.e
|
|
local k1 0.65
|
|
local k2 0.7
|
|
local zmidy (XH * 0.15)
|
|
include : dispiro
|
|
widths.lhs
|
|
g4.right.start SB 0 [heading RIGHTWARD]
|
|
g4 MIDDLE zmidy
|
|
g4.up.mid [mix MIDDLE RIGHTSB k1] (XH * k2) [heading UPWARD]
|
|
arcvh
|
|
g4.left.mid MIDDLE (XH - O) [heading LEFTWARD]
|
|
archv
|
|
g4.down.mid [mix MIDDLE SB k1] (XH * k2) [heading DOWNWARD]
|
|
g4 MIDDLE zmidy
|
|
g4.right.end RIGHTSB 0 [heading RIGHTWARD]
|
|
include : spiro-outline
|
|
corner MIDDLE (zmidy + 1)
|
|
g4.up.mid ([mix MIDDLE RIGHTSB k1] - 1) (XH * k2)
|
|
g4.left.mid MIDDLE XH
|
|
g4.down.mid ([mix MIDDLE SB k1] + 1) (XH * k2)
|
|
close
|
|
reverse-last
|
|
save 'latinayin' 0x1D25
|
|
|
|
|
|
define [ErTail left w dohook] : glyph-construction
|
|
local right WIDTH
|
|
local mid : mix left right 0.5
|
|
local rise : (WIDTH - left) * 0.3
|
|
local sw : fallback w (markFine * 2)
|
|
include : dispiro
|
|
widths.rhs sw
|
|
g2 (left - sw / 2 * HVCONTRAST) (XH * 0.5)
|
|
g2 (mid - sw * HVCONTRAST) (XH * 0.5 + rise)
|
|
include : dispiro
|
|
widths.rhs sw
|
|
flat mid (XH * 0.5 + rise) [heading DOWNWARD]
|
|
curl mid (XH * 0.5 + [if dohook 0 (rise - 1)]) [heading DOWNWARD]
|
|
if dohook {[hookend (XH * 0.5 - rise)]} {[arcvh]}
|
|
g4 (right - [if dohook (markFine * 2) 0]) (XH * 0.5 - [if dohook (rise * 0.5) rise]) [if dohook nothing [heading RIGHTWARD]]
|
|
#if dohook {[hookend (XH * 0.5 - rise)] [g4 right (XH * 0.5)]} {}
|
|
|
|
sketch # rhotichook
|
|
include : ErTail (-STROKE * HVCONTRAST) STROKE true
|
|
save 'rhotichook' 0x2DE
|
|
|
|
if [not recursive] : let [thinfont : Widen {'schwa' 'revlatinepsilon'} 0.85 1] : begin
|
|
sketch # er
|
|
include MarkSet.e
|
|
include thinfont.schwa
|
|
include : ErTail (WIDTH * 0.85 - SB - markFine * HVCONTRAST * 1.25)
|
|
save 'er' 0x25A
|
|
|
|
sketch # revlatinepsiloner
|
|
include MarkSet.e
|
|
include thinfont.revlatinepsilon
|
|
include : ErTail (WIDTH * 0.85 - SB - markFine * HVCONTRAST * 1.25)
|
|
save 'revlatinepsiloner' 0x25D
|
|
|
|
sketch # bidentalpercussive
|
|
local g : create-glyph : glyph-construction
|
|
include : HBarTop SB RIGHTSB (CAP * 0.4)
|
|
include : VBarLeft SB (CAP * 0.1) (CAP * 0.4)
|
|
include : VBarRight RIGHTSB (CAP * 0.1) (CAP * 0.4)
|
|
include g
|
|
apply-transform : Upright
|
|
apply-transform : Translate 0 (CAP / 2)
|
|
apply-transform : Italify
|
|
include g
|
|
save 'bidentalpercussive' 0x2AD
|
|
|
|
return [object SigmaShape PiShape EzhShape] |