6284 lines
200 KiB
Text
6284 lines
200 KiB
Text
###########################################################################################
|
|
# UNIFIED LETTERFORMS : LATIN ORIGINALS
|
|
###########################################################################################
|
|
|
|
$$include '../meta/macros.ptl'
|
|
|
|
import [mix linreg clamp fallback] from '../support/utils'
|
|
import [designParameters] from '../meta/aesthetics'
|
|
import [Dotless DoNotDeriveVariants] from "../support/gr"
|
|
|
|
glyph-module
|
|
|
|
glyph-block Letter-Shared : begin
|
|
glyph-block-import CommonShapes
|
|
|
|
glyph-block-export CreateDottedComposition
|
|
define [CreateDottedComposition sourceGid dstGid unicode] : WithDerivatives sourceGid dstGid
|
|
lambda [src sel] : glyph-construction
|
|
include [refer-glyph src] AS_BASE ALSO_METRICS
|
|
include : refer-glyph "dotAbove"
|
|
Dotless.set currentGlyph src
|
|
if [not sel] : assign-unicode unicode
|
|
|
|
glyph-block-export CreateCommaCaronComposition
|
|
define [CreateCommaCaronComposition sourceGid dstGid unicode] : WithDerivatives sourceGid dstGid
|
|
lambda [src sel] : glyph-construction
|
|
if [not sel] : assign-unicode unicode
|
|
define srcGlyph : query-glyph src
|
|
define commaOffset : (Width / 2) * [Math.pow (srcGlyph.advanceWidth / Width * 2) (2/3)]
|
|
include : refer-glyph "commaTR"
|
|
include : Upright
|
|
include : Translate commaOffset 0
|
|
include : Italify
|
|
include srcGlyph AS_BASE ALSO_METRICS
|
|
|
|
glyph-block Letter-Latin-Upper-I : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # I.straight
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : VBar df.middle 0 CAP
|
|
set currentGlyph.autoRefPriority (-2)
|
|
save 'I.straight'
|
|
|
|
sketch # I.line
|
|
local df : DivFrame para.diversityII
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : VBar df.middle 0 CAP
|
|
set currentGlyph.autoRefPriority (-2)
|
|
save 'I.line'
|
|
|
|
define [ISerifShape top] : glyph-construction
|
|
local df : DivFrame para.diversityI
|
|
include : VBar df.middle 0 top
|
|
include : CenterBottomSerif df.middle 0 (LongJut * df.div)
|
|
include : CenterTopSerif df.middle top (LongJut * df.div)
|
|
|
|
sketch # I.serifed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : ISerifShape CAP
|
|
|
|
save 'I.serifed'
|
|
|
|
select-variant 'I' 'I'
|
|
alias 'Iota' 0x399 'I'
|
|
alias 'cyrUkrainianI' 0x406 'I'
|
|
alias 'Palochka' 0x4C0 'I'
|
|
|
|
sketch # smcpI
|
|
local df : DivFrame para.diversityI
|
|
include df.markSet.e
|
|
set-width df.width
|
|
include : ISerifShape XH
|
|
save 'smcpI' 0x26A
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-I : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Shared : CreateDottedComposition
|
|
glyph-block-export IotaShape TailedIShape
|
|
|
|
### dotless i, i and iota
|
|
define [IotaShape top] : glyph-construction
|
|
local df : DivFrame para.diversityI
|
|
local middle df.middle
|
|
set-base-anchor 'above' middle top
|
|
include : tagged 'serifLT' : LeftwardTopSerif middle top (LongJut * df.div)
|
|
include : dispiro
|
|
widths.center
|
|
flat middle top [heading Downward]
|
|
curl middle Hook
|
|
arcvh
|
|
flat (middle + Hook - HalfStroke) HalfStroke
|
|
curl (middle + [Math.max HookX (LongJut * 1.05 * df.div)]) HalfStroke [heading Rightward]
|
|
|
|
sketch # iota
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : IotaShape XH
|
|
save 'iota' 0x3B9
|
|
save 'latiniota' 0x269
|
|
|
|
sketch # latinIota
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : IotaShape CAP
|
|
save 'latinIota' 0x196
|
|
|
|
sketch # dotlessi.straight
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : VBar (df.middle) 0 XH
|
|
set currentGlyph.autoRefPriority (-2)
|
|
save 'dotlessi.straight'
|
|
|
|
sketch # dotlessi.hooky
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
local balance : IBalance2 * df.div * df.div
|
|
include : VBar (df.middle + balance) 0 XH
|
|
include : LeftwardTopSerif (df.middle + balance) XH (LongJut * df.div)
|
|
save 'dotlessi.hooky'
|
|
|
|
sketch # dotlessi.zshaped
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : VBar (df.middle) 0 XH
|
|
include : LeftwardTopSerif (df.middle) XH (LongJut * df.div)
|
|
include : RightwardBottomSerif df.middle 0 (LongJut * df.div)
|
|
save 'dotlessi.zshaped'
|
|
|
|
sketch # dotlessi.line
|
|
local df : DivFrame para.diversityII
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : VBar (df.middle) 0 XH
|
|
save 'dotlessi.line'
|
|
|
|
sketch # dotlessi.serifed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
local balance : IBalance * df.div * df.div
|
|
include : VBar (df.middle + balance) 0 XH
|
|
include : LeftwardTopSerif (df.middle + balance) XH (LongJut * df.div - balance)
|
|
include : RightwardBottomSerif df.middle 0 (LongJut * df.div)
|
|
include : LeftwardBottomSerif df.middle 0 (LongJut * df.div)
|
|
save 'dotlessi.serifed'
|
|
|
|
sketch # dotlessi.italic
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
if para.isItalic
|
|
: then : begin
|
|
local shift : (1 - df.div) * 0.2
|
|
local left : [mix SB df.rightSB ([StrokeWidthBlend 0.42 0.46] - shift)] - HalfStroke * HVContrast
|
|
local right : mix SB df.rightSB (1.1 - shift)
|
|
local rightTerm : Math.max right (left + HookX + Stroke)
|
|
local middle : mix left right (0.55 * df.div)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat left XH [heading Downward]
|
|
curl left (SmallSmoothB * 0.8)
|
|
hookend O
|
|
g4 rightTerm (Hook * [StrokeWidthBlend 0.85 1] * df.div)
|
|
include : dispiro
|
|
flat (left - (LongJut * df.div) + HalfStroke * HVContrast) XH [widths 0 Stroke]
|
|
curl left XH
|
|
set-base-anchor 'above' (left + HalfStroke * HVContrast + [StrokeWidthBlend 0.25 0] * TanSlope * df.width) XH
|
|
set-base-anchor 'below' middle 0
|
|
: else : begin
|
|
include : IotaShape XH
|
|
save 'dotlessi.italic'
|
|
|
|
define [TailedIShape] : params [df top [xMiddle (df.middle - LBalance2)] [setMarks true] [hookScale 1]] : glyph-construction
|
|
local x0 : mix HalfStroke (HalfStroke + (Hook - Stroke + 1) * 0.85 * df.div + LBalance2) hookScale
|
|
local x1 : mix HalfStroke ([Math.max (Hook - HalfStroke + 1) (LongJut * df.div)] + LBalance2) hookScale
|
|
include : dispiro
|
|
widths.center
|
|
flat xMiddle top [heading Downward]
|
|
curl xMiddle [mix Stroke Hook hookScale]
|
|
arcvh
|
|
g4.right.mid (xMiddle + x0) (HalfStroke + O) [heading Rightward]
|
|
g4 (xMiddle + x1) (HalfStroke + (1 - 2 * hookScale) * O) [heading Rightward]
|
|
if setMarks : begin
|
|
set-base-anchor 'above' xMiddle top
|
|
set-base-anchor 'below' xMiddle 0
|
|
set-base-anchor 'overlay' xMiddle (top * OverlayPos)
|
|
set-base-anchor 'topright' (xMiddle + RightSB - Middle) top
|
|
|
|
sketch # dotlessi.tailed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : TailedIShape df XH
|
|
save 'dotlessi.tailed'
|
|
|
|
sketch # dotlessi.tailed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : VBar (df.middle) 0 XH
|
|
include : RightwardBottomSerif df.middle 0 (LongJut * df.div)
|
|
save 'dotlessi.hookybottom'
|
|
|
|
select-variant 'dotlessi' 0x131
|
|
sketch # iogonek.dotless
|
|
include [refer-glyph 'dotlessi'] AS_BASE
|
|
include : refer-glyph "ogonekBelow"
|
|
save 'iogonek.dotless'
|
|
|
|
CreateDottedComposition 'dotlessi' 'i' 'i'
|
|
CreateDottedComposition 'dotlessi' 'cyrUkrainiani' 0x456
|
|
|
|
turned 'turni' 0x1D09 'i' [lambda [] : this.advanceWidth / 2] (XH / 2) MarkSet.p
|
|
|
|
glyph-block Letter-Latin-Upper-J : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # J.straight
|
|
set-width Width
|
|
include MarkSet.capital
|
|
set-base-anchor 'above' (RightSB - Stroke * HVContrast * 0.75 - JBalance2) CAP
|
|
set-base-anchor 'overlay' (RightSB - Stroke * HVContrast * 0.75 - JBalance2) (CAP * OverlayPos)
|
|
|
|
local slope (Stroke * 0.00092)
|
|
local expand 0.35
|
|
local coexpand ((1 - expand) / 2)
|
|
|
|
local hookx (0.75 * SB)
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (RightSB - JBalance2) CAP [heading Downward]
|
|
curl (RightSB - JBalance2) Smooth
|
|
hookend O
|
|
g4 hookx Hook
|
|
|
|
save 'J.straight'
|
|
|
|
sketch # J.shorthook
|
|
set-width Width
|
|
include MarkSet.capital
|
|
|
|
local slope (Stroke * 0.00092)
|
|
local expand 0.35
|
|
local coexpand ((1 - expand) / 2)
|
|
local smooth : Hook + 0.75 * Stroke
|
|
|
|
local hookx (0.5 * SB)
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (RightSB - JBalance2) CAP [heading Downward]
|
|
curl (RightSB - JBalance2) smooth
|
|
straight.left.end [mix SB RightSB 0.3] O [heading Leftward]
|
|
|
|
save 'J.shorthook'
|
|
|
|
sketch # J.serifed
|
|
set-width Width
|
|
include [refer-glyph 'J.straight'] AS_BASE
|
|
include : LeftwardTopSerif (RightSB - HalfStroke * HVContrast - JBalance2) CAP LongJut
|
|
|
|
save 'J.serifed'
|
|
|
|
select-variant 'J' 'J'
|
|
alias 'cyrJe' 0x408 'J'
|
|
alias 'grkJ' 0x37F 'J'
|
|
|
|
glyph-block Letter-Latin-Lower-J : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Shared : CreateDottedComposition
|
|
|
|
### j and dotless j
|
|
sketch # dotlessj.straight
|
|
include MarkSet.p
|
|
local center : Middle + JBalance + HalfStroke * HVContrast
|
|
set-base-anchor 'above' (center - HVContrast * HalfStroke) XH
|
|
set-base-anchor 'overlay' (center - HVContrast * HalfStroke) (XH / 2)
|
|
local hookx : center - (Width * 0.5) - Stroke * HVContrast + OXHook
|
|
local turn : [mix center hookx 0.5] + CorrectionOMidS
|
|
include : dispiro
|
|
widths.rhs
|
|
flat center XH [heading Downward]
|
|
curl center (Descender + SmoothA)
|
|
hookend (Descender + O)
|
|
g4 hookx (Descender + JHook)
|
|
|
|
save 'dotlessj.straight'
|
|
|
|
sketch # dotlessj.line
|
|
include MarkSet.p
|
|
include : VBar Middle Descender XH
|
|
save 'dotlessj.line'
|
|
|
|
sketch # dotlessj.serifed
|
|
include MarkSet.p
|
|
include [refer-glyph 'dotlessj.straight'] AS_BASE
|
|
include : LeftwardTopSerif (Middle + JBalance) XH LongJut
|
|
|
|
set-base-anchor 'above' (Middle + JBalance - Stroke * 0.166 * HVContrast) XH
|
|
set-base-anchor 'overlay' (Middle + JBalance - Stroke * 0.166 * HVContrast) (XH / 2)
|
|
save 'dotlessj.serifed'
|
|
|
|
sketch # dotlessj.narrow
|
|
local df : DivFrame para.diversityII
|
|
set-width df.width
|
|
include df.markSet.p
|
|
local crossLeft : mix 0 SB (1 / 2)
|
|
local crossRight : mix df.width df.rightSB (1 / 2)
|
|
local terminal : crossLeft - OX * 2
|
|
local bar : df.middle + HalfStroke * HVContrast
|
|
local tTurn : Math.max (Hook * 0.9) (Stroke * 1.5) : Math.min Hook (Stroke * 1.75)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat [Math.min terminal (bar - tTurn - [Math.max (Stroke / 3) (df.width / 6)])] Descender
|
|
curl (bar - tTurn) Descender
|
|
archv
|
|
flat bar (Descender + tTurn)
|
|
curl bar XH [heading Upward]
|
|
set-base-anchor 'above' (df.middle) XH
|
|
set-base-anchor 'overlay' (df.middle) (XH / 2)
|
|
save 'dotlessj.narrow'
|
|
|
|
sketch # dotlessj.narrow-serifed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.p
|
|
local crossLeft : mix 0 SB (1 / 2)
|
|
local crossRight : mix df.width df.rightSB (1 / 2)
|
|
local terminal : crossLeft - OX * 2
|
|
local barCenter : df.middle + JBalance * df.div
|
|
local bar : barCenter + HalfStroke * HVContrast
|
|
local tTurn : Math.max (Hook * 0.9) (Stroke * 1.5) : Math.min Hook (Stroke * 1.75)
|
|
include : LeftwardTopSerif barCenter XH (LongJut * df.div)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat [Math.min terminal (bar - tTurn - [Math.max (Stroke / 3) (df.width / 6)])] Descender
|
|
curl (bar - tTurn) Descender
|
|
archv
|
|
flat bar (Descender + tTurn)
|
|
curl bar XH [heading Upward]
|
|
set-base-anchor 'above' barCenter XH
|
|
set-base-anchor 'overlay' barCenter (XH / 2)
|
|
save 'dotlessj.narrow-serifed'
|
|
|
|
select-variant 'dotlessj' 0x237
|
|
|
|
CreateDottedComposition 'dotlessj' 'j' 'j'
|
|
CreateDottedComposition 'dotlessj' 'grkj' 0x3F3
|
|
CreateDottedComposition 'dotlessj' 'cyrje' 0x458
|
|
|
|
sketch # dotlessjCurlyTail
|
|
include MarkSet.p
|
|
set-base-anchor 'above' (Middle + JBalance) XH
|
|
local fine : adviceBlackness 3.5
|
|
local rinner : LongJut / 2 - fine / 2
|
|
local m1 : Middle - HalfStroke * HVContrast + JBalance
|
|
local x2 : mix RightSB m1 0.25
|
|
local y2 : Descender + O
|
|
include : LeftwardTopSerif (Middle + JBalance) XH LongJut
|
|
include : dispiro
|
|
widths.lhs
|
|
flat m1 XH [heading Downward]
|
|
curl m1 (Descender + fine + rinner * 2)
|
|
CurlyTail fine rinner m1 Descender (m1 - LongJut) x2 y2
|
|
save 'dotlessjCurlyTail'
|
|
|
|
sketch # jcurlytail
|
|
include [refer-glyph 'dotlessjCurlyTail'] AS_BASE ALSO_METRICS
|
|
include : refer-glyph "dotAbove"
|
|
if [not currentGlyph.related] : set currentGlyph.related {.}
|
|
set currentGlyph.related.dotless 'dotlessjCurlyTail'
|
|
save 'jcurlytail' 0x29D
|
|
|
|
glyph-block Letter-Latin-Upper-L : begin
|
|
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [LShape top] : glyph-construction
|
|
include : VBarLeft (SB * 1.5) 0 top
|
|
include : HBarBottom (SB * 1.5 - O) (RightSB - OX) 0
|
|
if SLAB : begin
|
|
include : LeftwardBottomSerif (SB * 1.5) 0 SideJut
|
|
include : LeftwardTopSerif (SB * 1.5 + HVContrast * HalfStroke) top Jut
|
|
include : RightwardTopSerif (SB * 1.5 + HVContrast * HalfStroke) top MidJutSide
|
|
include : UpwardRightSerif (RightSB - OX) 0 VJut
|
|
|
|
sketch # L
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : LShape CAP
|
|
|
|
save 'L' 'L'
|
|
turned 'turnL' 0xA780 'L' Middle (CAP / 2)
|
|
|
|
sketch # Lcaron
|
|
include : refer-glyph "commaAbove"
|
|
apply-transform : Translate (Width + (RightSB - SB) * 0.375) 0
|
|
include [refer-glyph 'L'] AS_BASE
|
|
save 'Lcaron' 0x13D
|
|
|
|
sketch # Lslash
|
|
include [refer-glyph 'L'] AS_BASE ALSO_METRICS
|
|
local fine : 0.5 * OverlayStroke
|
|
local middle : mix Stroke CAP 0.5
|
|
include : dispiro
|
|
flat [mix 0 SB 0.5] (middle - LongJut * 0.4) [widths fine fine]
|
|
curl (1.6 * LongJut + [mix 0 SB 0.5]) (middle + LongJut * 0.4)
|
|
|
|
save 'Lslash' 0x141
|
|
|
|
sketch # LTildeOver
|
|
include [refer-glyph 'L'] AS_BASE ALSO_METRICS
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "tildeAboveOverlay"
|
|
apply-transform : Upright
|
|
apply-transform : Translate (SB * 1.5 + Stroke * HVContrast / 2 - markMiddle) (CAP * 0.525 - [mix aboveMarkBot aboveMarkTop 0.5])
|
|
apply-transform : Italify
|
|
save 'LTildeOver' 0x2C62
|
|
|
|
sketch # Ldot
|
|
include [refer-glyph 'L'] AS_BASE
|
|
include : Ring ([mix Stroke CAP 0.5] + DotRadius) ([mix Stroke CAP 0.5] - DotRadius) ([mix SB RightSB 0.65] - DotRadius) ([mix SB RightSB 0.65] + DotRadius)
|
|
save 'Ldot' 0x13F
|
|
|
|
sketch # Lbar
|
|
include [refer-glyph 'L'] AS_BASE
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + Stroke) (RightSB - Stroke) 0.55] (CAP * OverlayPos)
|
|
save 'Lbar' 0x23D
|
|
|
|
sketch # smcpL
|
|
include MarkSet.e
|
|
include : LShape XH
|
|
save 'smcpL' 0x29F
|
|
|
|
glyph-block Letter-Latin-Lower-L : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-Lower-I : IotaShape TailedIShape
|
|
glyph-block-import Letter-Shared : CreateCommaCaronComposition
|
|
|
|
sketch # l.hooky
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
local balance : LBalance2 * df.div * df.div
|
|
local middle : df.middle + balance
|
|
set-base-anchor 'above' middle CAP
|
|
set-base-anchor 'below' middle 0
|
|
set-base-anchor 'overlay' middle (CAP * OverlayPos)
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
include : VBar (df.middle + balance) 0 (CAP - Stroke)
|
|
include : LeftwardTopSerif (df.middle + balance) CAP (LongJut * df.div)
|
|
save 'l.hooky'
|
|
|
|
sketch # l.zshaped
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : VBar (df.middle) 0 (CAP - Stroke)
|
|
include : tagged 'serifLT' : LeftwardTopSerif (df.middle) CAP (LongJut * df.div)
|
|
include : tagged 'serifRB' : RightwardBottomSerif (df.middle) 0 (LongJut * df.div)
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
|
|
save 'l.zshaped'
|
|
|
|
sketch # l.line
|
|
local df : DivFrame para.diversityII
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : VBar (df.middle) 0 (CAP * 0.6)
|
|
include : VBar (df.middle) (CAP * 0.4) CAP
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
set currentGlyph.autoRefPriority (-2)
|
|
save 'l.line'
|
|
|
|
sketch # l.serifed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
local balance : LBalance * df.div * df.div
|
|
include : VBar (df.middle + balance) 0 CAP
|
|
include : LeftwardTopSerif (df.middle + balance) CAP ((LongJut * df.div) - balance)
|
|
include : CenterBottomSerif df.middle 0 (LongJut * df.div)
|
|
set-base-anchor 'overlay' (df.middle + balance / 2) (CAP * OverlayPos)
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
save 'l.serifed'
|
|
|
|
sketch # l.italic
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
if para.isItalic
|
|
: then : begin
|
|
local shift : (1 - df.div) * 0.4
|
|
local left : mix SB df.rightSB (0.3 - shift)
|
|
local right : mix SB df.rightSB (1.1 - shift)
|
|
local rightTerm : Math.max right (left + HookX + Stroke)
|
|
local middle : mix left right (0.54 * df.div)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat left CAP [heading Downward]
|
|
curl left (SmallSmoothB * 0.85)
|
|
hookend O
|
|
g4 rightTerm (Hook * [StrokeWidthBlend 0.85 1] * df.div)
|
|
include : tagged 'serifLT': dispiro
|
|
flat (left - (LongJut * df.div) + HalfStroke * HVContrast) CAP [widths 0 Stroke]
|
|
curl left CAP
|
|
set-base-anchor 'above' (left + HalfStroke) CAP
|
|
set-base-anchor 'below' middle 0
|
|
set-base-anchor 'overlay' (left + HalfStroke) (CAP * OverlayPos)
|
|
set-base-anchor 'topright' (left + HalfStroke + RightSB - Middle) CAP
|
|
: else : begin
|
|
include : IotaShape CAP
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
save 'l.italic'
|
|
|
|
sketch # l.phoneticLeft
|
|
local df : DivFrame 1
|
|
set-width df.width
|
|
include df.markSet.b
|
|
define middle : SB + Stroke * HVContrast
|
|
include : dispiro
|
|
widths.center
|
|
flat middle CAP [heading Downward]
|
|
curl middle Hook
|
|
arcvh
|
|
flat (middle + Hook - HalfStroke) HalfStroke
|
|
curl [Math.max RightSB (middle + [Math.max HookX (LongJut * 1.05 * df.div)])] HalfStroke [heading Rightward]
|
|
set-base-anchor 'topright' (df.middle + RightSB - Middle) CAP
|
|
save 'l.phoneticLeft'
|
|
|
|
sketch # l.tailed
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : TailedIShape df CAP
|
|
save 'l.tailed'
|
|
|
|
sketch # l.hookybottom
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include df.markSet.b
|
|
local middle : df.middle - LBalance2
|
|
set-base-anchor 'above' middle CAP
|
|
set-base-anchor 'below' middle 0
|
|
set-base-anchor 'overlay' middle (CAP * OverlayPos)
|
|
set-base-anchor 'topright' (middle + RightSB - Middle) CAP
|
|
include : VBar middle 0 CAP
|
|
include : RightwardBottomSerif middle 0 (LongJut * df.div)
|
|
save 'l.hookybottom'
|
|
|
|
|
|
select-variant 'l' 'l'
|
|
alias 'palochka' 0x4CF 'l'
|
|
turned 'turnl' 0xA781 'l' Middle (XH / 2) MarkSet.p
|
|
|
|
CreateCommaCaronComposition 'l' 'lcaron' 0x13E
|
|
|
|
local LDotOptions : list
|
|
list 'hooky' 0
|
|
list 'zshaped' Stroke
|
|
list 'serifed' Stroke
|
|
list 'italic' Stroke
|
|
list 'line' 0
|
|
list 'tailed' Stroke
|
|
list 'hookybottom' Stroke
|
|
|
|
foreach {suffix y0} [items-of LDotOptions] : if [query-glyph ('l.' + suffix)]
|
|
create-glyph ('ldot.' + suffix) : glyph-construction
|
|
local df : DivFrame para.diversityI
|
|
set-width df.width
|
|
include [refer-glyph ('l.' + suffix)] AS_BASE
|
|
apply-transform : Translate (df.width / 2 - [query-glyph ('l.' + suffix)].advanceWidth / 2) 0
|
|
apply-transform : Translate (-DotRadius / 2) 0
|
|
include : RingAt [Math.max (df.middle + HalfStroke + DotRadius) (df.rightSB - DotRadius)] [mix y0 CAP 0.5] DotRadius
|
|
|
|
select-variant 'ldot' 0x140 (follow -- 'l')
|
|
|
|
sketch # lrtail
|
|
local df : DivFrame para.diversityI
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Translate (df.middle + LBalance2 + HalfStroke * HVContrast) 0
|
|
include : refer-glyph "l.hooky"
|
|
include df.markSet.if
|
|
|
|
save 'lrtail' 0x26D
|
|
|
|
sketch # lcurlytail
|
|
include MarkSet.b
|
|
local fine : adviceBlackness 3.5
|
|
local rinner : LongJut / 2 - fine / 2
|
|
local m1 : Middle + HalfStroke * HVContrast
|
|
local x2 : mix SB m1 0.25
|
|
local y2 : - fine
|
|
include : LeftwardTopSerif Middle CAP LongJut
|
|
include : dispiro
|
|
widths.rhs
|
|
flat m1 CAP [heading Downward]
|
|
curl m1 (fine + rinner * 2)
|
|
CurlyTail fine rinner m1 0 (m1 + LongJut) x2 y2
|
|
|
|
save 'lcurlytail' 0x234
|
|
|
|
sketch # ltildeover
|
|
local df : DivFrame para.diversityI
|
|
include [refer-glyph 'l.serifed'] AS_BASE ALSO_METRICS
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "tildeAboveOverlay"
|
|
apply-transform : Upright
|
|
apply-transform : Translate (df.middle - markMiddle) (CAP * 0.525 - [mix aboveMarkBot aboveMarkTop 0.5])
|
|
apply-transform : Italify
|
|
save 'ltildeover' 0x26B
|
|
|
|
define [Belt middle] : glyph-construction
|
|
local fine : adviceBlackness 4.5
|
|
local r : XH * 0.05
|
|
include : dispiro
|
|
widths.rhs fine
|
|
flat middle (CapMiddle + r) [heading Leftward]
|
|
curl (middle - HalfStroke - r * 1.5) (CapMiddle + r)
|
|
archv
|
|
g4.down.mid (middle - HalfStroke - r * 2.5) CapMiddle [heading Downward]
|
|
arcvh
|
|
flat (middle - HalfStroke - r * 1.5) (CapMiddle - r)
|
|
curl (middle + HalfStroke + r * 1.5 + fine) (CapMiddle - r)
|
|
|
|
sketch # lbelt
|
|
local df : DivFrame para.diversityI
|
|
include [refer-glyph 'l.serifed'] AS_BASE ALSO_METRICS
|
|
include : Belt (df.middle + LBalance * df.div * df.div)
|
|
save 'lbelt' 0x26C
|
|
|
|
sketch # lbeltrtail
|
|
local df : DivFrame para.diversityI
|
|
include [refer-glyph 'lrtail'] AS_BASE ALSO_METRICS
|
|
include : Belt (df.middle + LBalance2 * df.div * df.div)
|
|
save 'lbeltrtail' 0xA78E
|
|
|
|
sketch # looprevesh
|
|
include MarkSet.if
|
|
local fine : adviceBlackness 4
|
|
include : dispiro
|
|
widths.center fine
|
|
g4.down.start Middle (CAP - fine * 1.5) [heading Downward]
|
|
arcvh
|
|
g4 (Middle - fine * 1) (CAP - fine * 2.5) [heading Leftward]
|
|
archv
|
|
g4 (Middle - fine * 2) (CAP - fine * 1.5) [heading Upward]
|
|
arcvh
|
|
g4 (Middle - fine * 1) (CAP - fine * 0.5) [heading Rightward]
|
|
archv
|
|
flat Middle (CAP - fine * 1.5) [widths.heading HalfStroke HalfStroke Downward]
|
|
curl Middle 0 [heading Downward]
|
|
arcvh
|
|
straight.right.end (Middle + HookX) (-Hook)
|
|
save 'looprevesh' 0x1AA
|
|
|
|
|
|
glyph-block Letter-Latin-V : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export VShape VShapeOutline
|
|
|
|
define cornerdist : HalfStroke * HVContrast * 1.15
|
|
define VCurviness 0.3
|
|
define VShapeFine : Math.max
|
|
Stroke * [if SLAB para.vtipfineSlab para.vtipfine]
|
|
cornerdist * 1.2
|
|
define VShapeFineStraight : Math.max [adviceBlackness 7] [Stroke * 0.66]
|
|
define VShapeMiddleWidth : adviceBlackness 3
|
|
define pInktrap 0.5
|
|
|
|
define StraightSbShrink : mix 1 (designParameters.straightVShapeSbShrink * [StrokeWidthBlend 1 0.25]) : if SLAB 0.75 1
|
|
define [VShapeTopFlat top] : if SLAB [Math.min (top - Stroke) (top * 0.9)] (top * 0.9)
|
|
|
|
define [VShapeOutline] : params [top [sw Stroke] barStraight div] : glyph-construction
|
|
local df : DivFrame div
|
|
local fine : [if barStraight VShapeFineStraight VShapeFine] * sw / Stroke
|
|
local dgCor : diagCor top (Width / 2) 0 (sw * 2)
|
|
local clearance : 0 - OX
|
|
|
|
if barStraight : begin
|
|
local vxStartL : df.leftSB * StraightSbShrink + clearance
|
|
local vxEndL : df.middle - cornerdist + clearance
|
|
local vxStartR : df.width - df.leftSB * StraightSbShrink - clearance
|
|
local vxEndR : df.middle + cornerdist - clearance
|
|
include : spiro-outline
|
|
flat [mix vxStartL vxEndL 0] [mix top 0 0]
|
|
curl [mix vxStartL vxEndL pInktrap] [mix top 0 pInktrap]
|
|
corner [mix vxStartL vxEndL 1] [mix top 0 1]
|
|
corner [mix vxStartR vxEndR 1] [mix top 0 1]
|
|
flat [mix vxStartR vxEndR pInktrap] [mix top 0 pInktrap]
|
|
curl [mix vxStartR vxEndR 0] [mix top 0 0]
|
|
: else : begin
|
|
local vxStartL : df.leftSB + clearance
|
|
local vxEndL : df.middle - cornerdist + clearance
|
|
local vxStartR : df.width - df.leftSB - clearance
|
|
local vxEndR : df.middle + cornerdist - clearance
|
|
include : spiro-outline
|
|
flat vxStartL top
|
|
curl vxStartL [VShapeTopFlat top]
|
|
quadcontrols 0 VCurviness 9 unimportant
|
|
corner vxEndL 0
|
|
corner vxEndR 0
|
|
quadcontrols 1 (1 - VCurviness) 9 unimportant
|
|
flat vxStartR [VShapeTopFlat top]
|
|
curl vxStartR top
|
|
|
|
define [VShape] : params [top [sw Stroke] barStraight div [slab SLAB]] : glyph-construction
|
|
local df : DivFrame div
|
|
local fine : Math.min sw : if barStraight VShapeFineStraight VShapeFine
|
|
local dgCor : diagCor (2 * top) Width 0 (2 * sw)
|
|
if barStraight : begin
|
|
local vxStartL : df.leftSB * StraightSbShrink
|
|
local vxEndL : df.middle - cornerdist
|
|
local vxStartR : df.width - df.leftSB * StraightSbShrink
|
|
local vxEndR : df.middle + cornerdist
|
|
local midSW : VShapeMiddleWidth / Stroke * sw
|
|
include : tagged 'strokeDown' : dispiro
|
|
widths.lhs (sw * dgCor)
|
|
flat [mix vxStartL vxEndL 0] [mix top 0 0] [heading Downward]
|
|
curl [mix vxStartL vxEndL pInktrap] [mix top 0 pInktrap] [widths.lhs midSW]
|
|
g4 [mix vxStartL vxEndL 1] [mix top 0 1] [widths.lhs fine]
|
|
include : tagged 'strokeUp' : dispiro
|
|
widths.rhs (sw * dgCor)
|
|
flat [mix vxStartR vxEndR 0] [mix top 0 0] [heading Downward]
|
|
curl [mix vxStartR vxEndR pInktrap] [mix top 0 pInktrap] [widths.rhs midSW]
|
|
g4 [mix vxStartR vxEndR 1] [mix top 0 1] [widths.rhs fine]
|
|
: else : begin
|
|
include : tagged 'strokeDown' : dispiro
|
|
widths.lhs sw
|
|
flat df.leftSB top [heading Downward]
|
|
curl df.leftSB [VShapeTopFlat top] [heading Downward]
|
|
quadcontrols 0 VCurviness 9 unimportant
|
|
g4 (df.middle - cornerdist) 0 [widths.lhs fine]
|
|
include : tagged 'strokeUp' : dispiro
|
|
widths.rhs sw
|
|
flat df.rightSB top [heading Downward]
|
|
curl df.rightSB [VShapeTopFlat top] [heading Downward]
|
|
quadcontrols 0 VCurviness 9 unimportant
|
|
g4 (df.middle + cornerdist) 0 [widths.rhs fine]
|
|
|
|
#bottom cap
|
|
include : spiro-outline
|
|
corner (df.middle + cornerdist) 0
|
|
corner (df.middle - cornerdist) 0
|
|
corner df.middle fine
|
|
|
|
if slab : include : AIVSerifs top
|
|
|
|
sketch # V
|
|
set-width Width
|
|
include MarkSet.capital
|
|
branch
|
|
include : VShape CAP Stroke true
|
|
save 'V.straight'
|
|
branch
|
|
include : VShape CAP Stroke false
|
|
save 'V.curly'
|
|
|
|
sketch # v
|
|
include MarkSet.e
|
|
branch
|
|
include : VShape XH Stroke true
|
|
save 'v.straight'
|
|
branch
|
|
include : VShape XH Stroke false
|
|
save 'v.curly'
|
|
|
|
define [VHooktopShape top _stroke barStraight] : glyph-construction
|
|
include : VShape top [fallback _stroke Stroke] barStraight
|
|
eject-contour 'serifRT'
|
|
eject-contour 'strokeUp'
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
straight.left.start (RightSB + HookX / 3) (top - Stroke)
|
|
g4 (RightSB - HookX / 3) (top - HalfStroke - Hook)
|
|
quadcontrols 0.4 0.75 64 unimportant
|
|
g4 (Middle + cornerdist) 0 [widths.rhs VShapeFine]
|
|
|
|
sketch # vhooktop
|
|
include MarkSet.e
|
|
branch
|
|
include : VHooktopShape XH Stroke true
|
|
save 'vhooktop.straight'
|
|
save 'cyrizhitsa.straight'
|
|
branch
|
|
include : VHooktopShape XH Stroke false
|
|
save 'vhooktop.curly'
|
|
save 'cyrizhitsa.curly'
|
|
|
|
|
|
sketch # cyrIzhitsa
|
|
include MarkSet.capital
|
|
branch
|
|
include : VHooktopShape CAP Stroke true
|
|
save 'cyrIzhitsa.straight'
|
|
branch
|
|
include : VHooktopShape CAP Stroke false
|
|
save 'cyrIzhitsa.curly'
|
|
|
|
select-variant 'V' 'V'
|
|
select-variant 'v' 'v'
|
|
select-variant 'vhooktop' 0x2C71 (follow -- 'v')
|
|
select-variant 'cyrizhitsa' 0x475 (follow -- 'v')
|
|
select-variant 'cyrIzhitsa' 0x474 (follow -- 'V')
|
|
|
|
|
|
turned 'turnv.straight' nothing 'v.straight' Middle (XH / 2)
|
|
turned 'turnv.curly' nothing 'v.curly' Middle (XH / 2)
|
|
select-variant 'turnv' 0x28C (follow -- 'Lambda')
|
|
|
|
sketch # nu
|
|
include MarkSet.e
|
|
|
|
local xmid : Middle + HalfStroke * 0.75
|
|
|
|
include : dispiro
|
|
g4 (SB + 0.4 * Stroke * HVContrast) (XH - O) [widths.rhs]
|
|
bezcontrols 0.33 0.2 1 0.76 6 important
|
|
g4.down.end xmid 0 [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
|
|
|
|
save 'nu' 0x3BD
|
|
|
|
glyph-block Letter-Latin-Upper-A : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-V : VShapeOutline VShape
|
|
glyph-block-export LambdaShape AMaskShape DeltaShape
|
|
|
|
define [AMaskShape top sw barStraight div] : create-glyph : glyph-construction
|
|
include : VShapeOutline top sw barStraight div
|
|
include : FlipAround ([DivFrame div].width / 2) (top / 2)
|
|
|
|
sketch # A
|
|
set-width Width
|
|
include MarkSet.capital
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
|
|
local ABarPosition : mix [if SLAB Stroke 0] CAP (XH / 2 / CAP)
|
|
|
|
branch
|
|
include : VShape CAP Stroke true
|
|
include : FlipAround Middle (CAP / 2)
|
|
include : intersection
|
|
HBarTop 0 Width ABarPosition
|
|
AMaskShape CAP Stroke true 1
|
|
# include : AMaskShape CAP Stroke true 1
|
|
save 'A.straight'
|
|
save 'Alpha.straight'
|
|
save 'cyrA.straight'
|
|
|
|
branch
|
|
include : VShape CAP Stroke false
|
|
include : FlipAround Middle (CAP / 2)
|
|
include : intersection
|
|
HBarTop 0 Width ABarPosition
|
|
AMaskShape CAP Stroke false 1
|
|
save 'A.curly'
|
|
save 'Alpha.curly'
|
|
save 'cyrA.curly'
|
|
|
|
select-variant 'A' 'A'
|
|
select-variant 'Alpha' 0x391 (follow -- 'A')
|
|
select-variant 'cyrA' 0x410 (follow -- 'A')
|
|
|
|
turned 'turnA.straight' nothing 'A.straight' Middle (CAP / 2)
|
|
turned 'turnA.curly' nothing 'A.curly' Middle (CAP / 2)
|
|
select-variant 'turnA' 0x2C6F (follow -- 'A')
|
|
|
|
# Lambda
|
|
define [LambdaShape] : params [top sw barStraight div [slab SLAB]] : glyph-construction
|
|
local df : DivFrame [fallback div 1]
|
|
include : VShape top sw barStraight div (slab -- false)
|
|
include : FlipAround df.middle (top / 2)
|
|
if slab : begin
|
|
include : tagged 'serif' : CenterBottomSerif (SB + sw / 2 * HVContrast) 0 Jut
|
|
include : tagged 'serif' : CenterBottomSerif (RightSB - sw / 2 * HVContrast) 0 Jut
|
|
|
|
sketch # Lambda
|
|
include MarkSet.capital
|
|
branch
|
|
include : LambdaShape CAP Stroke true
|
|
save 'Lambda.straight'
|
|
save 'latinLambda.straight'
|
|
branch
|
|
include : LambdaShape CAP Stroke false
|
|
save 'Lambda.curly'
|
|
save 'latinLambda.curly'
|
|
|
|
select-variant 'Lambda' 0x39B
|
|
select-variant 'latinLambda' 0x245 (follow -- 'Lambda')
|
|
|
|
# Delta
|
|
define [DeltaShape top sw barStraight div] : union
|
|
LambdaShape top sw barStraight div (slab -- false)
|
|
intersection
|
|
HBarBottom 0 Width 0 sw
|
|
AMaskShape top sw barStraight div
|
|
if [not SLAB] [glyph-construction] : difference
|
|
union
|
|
LeftwardBottomSerif SB 0 SideJut
|
|
RightwardBottomSerif RightSB 0 SideJut
|
|
AMaskShape top sw barStraight div
|
|
sketch # Delta
|
|
include MarkSet.capital
|
|
branch
|
|
include : DeltaShape CAP Stroke true
|
|
save 'Delta.straight'
|
|
branch
|
|
include : DeltaShape CAP Stroke false
|
|
save 'Delta.curly'
|
|
|
|
select-variant 'Delta' 0x394
|
|
|
|
glyph-block Letter-Latin-Lower-A : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # a.doublestorey
|
|
set-width Width
|
|
include MarkSet.e
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
local stroke : adviceBlackness2 2.875 2 XH
|
|
local bartop (XH * OverlayPos * 1.02 + stroke * 0.425)
|
|
local lowslope : shoulderMidSlope ShoulderFine nothing (-1)
|
|
local lowmiddle : [mix (SB + OX) (RightSB - stroke / 2 * HVContrast) [linreg 72 0.51 126 0.58 stroke]] + CorrectionOMidS * 0.5
|
|
local barsmooth : mix SB RightSB 0.55
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
flat RightSB 0 [heading Upward]
|
|
curl RightSB (XH - SmoothB * [StrokeWidthBlend 0.9 0.81 stroke])
|
|
hookend (XH - O)
|
|
g4 (SB - OXHook) (XH - AHook)
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
flat (RightSB + O) bartop [heading Leftward]
|
|
curl barsmooth bartop
|
|
archv
|
|
g4 (SB + OX * 1.5) (bartop * 0.95 * (SmallSmoothB / (SmallSmoothA + SmallSmoothB)))
|
|
arcvh
|
|
g4 (lowmiddle + (-lowslope) * stroke) O [heading {.y 1 .x lowslope}]
|
|
archv 16
|
|
straight.up.end (RightSB - stroke * HVContrast + ShoulderFine * HVContrast) (SmallSmoothB * 0.9) [widths.lhs ShoulderFine]
|
|
if SLAB : begin
|
|
include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
|
|
save 'a.doublestorey'
|
|
|
|
sketch # a.singlestorey
|
|
set-width Width
|
|
include MarkSet.e
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
include : OBarRightShape
|
|
if SLAB
|
|
: then : begin
|
|
include : VBarRight RightSB 0 XH
|
|
include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
: else : begin
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RightSB XH [heading Downward]
|
|
curl RightSB SmoothA [heading Downward]
|
|
g4 [mix SB RightSB (1 + 0.4 * TanSlope)] 0 [heading Downward]
|
|
set-base-anchor 'bottomright' [mix SB RightSB 1.075] 0
|
|
save 'a.singlestorey'
|
|
|
|
select-variant 'a' 'a'
|
|
alias 'cyra' 0x430 'a'
|
|
|
|
sketch # turnlargescripta
|
|
include MarkSet.capital
|
|
include : union
|
|
OBarRightShape CAP
|
|
spiro-outline
|
|
corner RightSB 0
|
|
corner (RightSB - Stroke * HVContrast) 0
|
|
corner (RightSB - Stroke * HVContrast) (CAP - Stroke / 2)
|
|
corner RightSB (CAP - O)
|
|
save 'largescripta' 0x2C6D
|
|
include : FlipAround Middle (CAP / 2)
|
|
save 'turnlargescripta' 0x2C70
|
|
|
|
sketch # scripta
|
|
include MarkSet.e
|
|
include : union
|
|
OBarRightShape
|
|
spiro-outline
|
|
corner RightSB 0
|
|
corner (RightSB - Stroke * HVContrast) 0
|
|
corner (RightSB - Stroke * HVContrast) (XH - Stroke / 2)
|
|
corner RightSB (XH - O)
|
|
if SLAB : include : tagged 'serifRB' RightwardBottomSerif RightSB 0 SideJut
|
|
save 'scripta' 0x0251
|
|
include : FlipAround Middle (XH / 2)
|
|
save 'turnscripta' 0x252
|
|
|
|
sketch # invLatinAlpha
|
|
include MarkSet.e
|
|
include : union
|
|
OBarRightShape
|
|
spiro-outline
|
|
corner RightSB XH
|
|
corner (RightSB - Stroke * HVContrast) XH
|
|
corner (RightSB - Stroke * HVContrast) (Stroke / 2)
|
|
corner RightSB O
|
|
if SLAB : include : tagged 'serifRT' : RightwardTopSerif RightSB XH SideJut
|
|
save 'invLatinAlpha' 0xAB64
|
|
|
|
turned 'turna' 0x250 'a.doublestorey' Middle (XH / 2)
|
|
|
|
sketch # artail
|
|
include [refer-glyph 'a.doublestorey'] AS_BASE
|
|
eject-contour 'serifRB'
|
|
include : refer-glyph "rtailBR"
|
|
save 'artail' 0x1D8F
|
|
|
|
glyph-block Letter-Latin-W : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
### W and w
|
|
define [WShape top barStraight df] : glyph-construction
|
|
local fineOuter : if barStraight
|
|
adviceBlackness WShape.fineSOuter [Math.sqrt df.div]
|
|
adviceBlackness WShape.fineOuter df.div
|
|
local fineInner : if barStraight
|
|
adviceBlackness WShape.fineSInner [Math.sqrt df.div]
|
|
adviceBlackness WShape.fineInner df.div
|
|
local fineHeight : (fineOuter + fineInner) / 2
|
|
|
|
local hwCO : if barStraight
|
|
(1 / 2) * [adviceBlackness WShape.hwCOS df.div]
|
|
(1 / 2) * [adviceBlackness WShape.hwCO df.div]
|
|
local delimBias : hwCO * HVContrast
|
|
local fineOffsetOuter : hwCO * HVContrast
|
|
local fineOffsetInner : hwCO * HVContrast
|
|
local m1 : [mix (df.leftSB + delimBias) (df.rightSB - delimBias) : if barStraight WShape.m1S WShape.m1] + [if barStraight O 0]
|
|
local m2 : [mix (df.leftSB + delimBias) (df.rightSB - delimBias) : if barStraight WShape.m2S WShape.m2] - [if barStraight O 0]
|
|
local topWithoutSerif : if SLAB (top - Stroke) top
|
|
local wMidHeight : if barStraight (topWithoutSerif * [Math.min 1 (df.div * 0.9)]) (top * 0.6)
|
|
|
|
if barStraight : begin
|
|
include : tagged 'strokeDown1' : dispiro
|
|
widths.lhs
|
|
flat (df.leftSB + O * 2) top [heading Downward]
|
|
g4 (m1 - fineOffsetOuter) 0 [widths.lhs fineOuter]
|
|
: else : begin
|
|
include : tagged 'strokeDown1' : dispiro
|
|
widths.lhs
|
|
flat df.leftSB top [heading Downward]
|
|
curl df.leftSB (top * 0.75) [heading Downward]
|
|
quadcontrols 0 0.3 6 unimportant
|
|
g4 (m1 - fineOffsetOuter) 0 [widths.lhs fineOuter]
|
|
|
|
# bottom cap 1
|
|
define [InnerShapes] : union
|
|
spiro-outline
|
|
corner (m1 + fineOffsetInner) 0
|
|
corner (m1 - fineOffsetOuter) 0
|
|
corner m1 fineHeight
|
|
spiro-outline
|
|
corner (df.middle + fineOffsetInner) wMidHeight
|
|
corner df.middle (wMidHeight - fineHeight)
|
|
corner (df.middle - fineOffsetInner) wMidHeight
|
|
spiro-outline
|
|
corner (m2 + fineOffsetOuter) 0
|
|
corner (m2 - fineOffsetInner) 0
|
|
corner m2 fineHeight
|
|
|
|
dispiro
|
|
widths.lhs fineInner
|
|
flat (df.middle - fineOffsetInner) wMidHeight
|
|
curl (m1 + fineOffsetInner) 0 [widths.rhs fineInner]
|
|
dispiro
|
|
widths.rhs fineInner
|
|
flat (df.middle + fineOffsetInner) wMidHeight
|
|
curl (m2 - fineOffsetInner) 0 [widths.lhs fineInner]
|
|
|
|
define [InnerStrokeMask] : union
|
|
spiro-outline
|
|
corner 0 0
|
|
corner df.width 0
|
|
corner df.width (-df.width)
|
|
corner 0 (-df.width)
|
|
spiro-outline
|
|
corner 0 wMidHeight
|
|
corner df.width wMidHeight
|
|
corner df.width (wMidHeight + df.width)
|
|
corner 0 (wMidHeight + df.width)
|
|
|
|
include : difference [InnerShapes] [InnerStrokeMask]
|
|
|
|
if barStraight : begin
|
|
include : tagged 'strokeUp2' : dispiro
|
|
widths.rhs
|
|
flat (df.rightSB - O * 2) top [heading Downward]
|
|
g4 (m2 + fineOffsetOuter) 0 [widths.rhs fineOuter]
|
|
: else : begin
|
|
include : tagged 'strokeUp2' : dispiro
|
|
widths.rhs
|
|
flat df.rightSB top [heading Downward]
|
|
curl df.rightSB (top * 0.75) [heading Downward]
|
|
quadcontrols 0 0.3 6 unimportant
|
|
g4 (m2 + fineOffsetOuter) 0 [widths.rhs fineOuter]
|
|
|
|
include : AIVSerifs top df.leftSB df.rightSB
|
|
|
|
set WShape.fineOuter 5
|
|
set WShape.fineInner 6
|
|
set WShape.fineSOuter 5.5
|
|
set WShape.fineSInner 5.5
|
|
set WShape.hwCO 5
|
|
set WShape.hwCOS 3.5
|
|
set WShape.m1 0.25
|
|
set WShape.m2 : 1 - WShape.m1
|
|
set WShape.m1S 0.235
|
|
set WShape.m2S : 1 - WShape.m1S
|
|
|
|
define [WonOverlay df] : glyph-construction
|
|
include : HOverlayBar [mix SB 0 0.7] [mix df.rightSB df.width 0.7] (CAP * 0.6)
|
|
include : HOverlayBar [mix SB 0 0.7] [mix df.rightSB df.width 0.7] (CAP * 0.35)
|
|
|
|
sketch # W
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
branch
|
|
include : WShape CAP true df
|
|
save 'W.straight'
|
|
save 'cyrWe.straight'
|
|
branch
|
|
include : WonOverlay df
|
|
save 'symbol/currency/wonSign.straight'
|
|
branch
|
|
include : WShape CAP false df
|
|
save 'W.curly'
|
|
save 'cyrWe.curly'
|
|
branch
|
|
include : WonOverlay df
|
|
save 'symbol/currency/wonSign.curly'
|
|
|
|
sketch # w
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
branch
|
|
include : WShape XH true df
|
|
save 'w.straight'
|
|
save 'cyrwe.straight'
|
|
branch
|
|
include : WShape XH false df
|
|
save 'w.curly'
|
|
save 'cyrwe.curly'
|
|
|
|
define [WHooktopShape top barStraight df] : glyph-construction
|
|
local fineOuter : if barStraight
|
|
adviceBlackness WShape.fineSOuter [Math.sqrt df.div]
|
|
adviceBlackness WShape.fineOuter df.div
|
|
|
|
local hwCO : if barStraight
|
|
(1 / 2) * [adviceBlackness WShape.hwCOS df.div]
|
|
(1 / 2) * [adviceBlackness WShape.hwCO df.div]
|
|
local delimBias : hwCO * HVContrast
|
|
local fineOffsetOuter : hwCO * HVContrast
|
|
local fineOffsetInner : hwCO * HVContrast
|
|
local m2 : [mix (df.leftSB + delimBias) (df.rightSB - delimBias) : if barStraight WShape.m2S WShape.m2] - [if barStraight O 0]
|
|
|
|
include : WShape top barStraight df
|
|
|
|
# Eject unnecessary contours
|
|
eject-contour 'strokeUp2'
|
|
if SLAB : eject-contour 'serifRT'
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
straight.down.start df.rightSB (top - Hook) [heading Downward]
|
|
quadcontrols 0 0.3 6 unimportant
|
|
g4 (m2 + fineOffsetOuter) 0 [widths.rhs fineOuter]
|
|
|
|
include : VerticalHook (df.rightSB - HalfStroke * HVContrast) (top - Hook) (HookX * 0.65) (-Hook + HalfStroke)
|
|
|
|
sketch # Whooktop
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
branch
|
|
include : WHooktopShape CAP true df
|
|
save 'Whooktop.straight'
|
|
branch
|
|
include : WHooktopShape CAP false df
|
|
save 'Whooktop.curly'
|
|
|
|
sketch # whooktop
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
branch
|
|
include : WHooktopShape XH true df
|
|
save 'whooktop.straight'
|
|
branch
|
|
include : WHooktopShape XH false df
|
|
save 'whooktop.curly'
|
|
|
|
define [LowerWWShape df straightBar] : glyph-construction
|
|
include : WShape (CAP / 2) straightBar df
|
|
apply-transform : Upright
|
|
apply-transform : Translate 0 (CAP / 2)
|
|
apply-transform : Italify
|
|
include : WShape (CAP / 2) straightBar df
|
|
sketch # ww
|
|
local df : DivFrame 1 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
branch
|
|
include : LowerWWShape df true
|
|
save 'ww.straight'
|
|
branch
|
|
include : LowerWWShape df false
|
|
save 'ww.curly'
|
|
|
|
select-variant 'W' 'W'
|
|
select-variant 'cyrWe' 0x51C (follow -- 'W')
|
|
select-variant 'Whooktop' 0x2C72 (follow -- 'W')
|
|
select-variant 'symbol/currency/wonSign' 0x20A9 (follow -- 'W')
|
|
select-variant 'w' 'w'
|
|
select-variant 'cyrwe' 0x51D (follow -- 'w')
|
|
select-variant 'ww' 0x2AC (follow -- 'w')
|
|
select-variant 'whooktop' 0x2C73 (follow -- 'w')
|
|
|
|
turned 'turnw.straight' nothing 'w.straight' (Middle * para.diversityM) (XH / 2)
|
|
turned 'turnw.curly' nothing 'w.curly' (Middle * para.diversityM) (XH / 2)
|
|
select-variant 'turnw' 0x28D (follow -- 'w')
|
|
|
|
glyph-block Letter-Latin-X : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export HalfXStrand XStrand
|
|
|
|
define [HalfXStrand stb slab _leftx lefty rightx righty turn pStraight tension _fine] : glyph-construction
|
|
local sbCor : if stb ([StrokeWidthBlend 1 6] * OX * ([Math.abs (lefty - righty)] / CAP)) 0
|
|
local leftx : _leftx + ((HalfStroke * HVContrast + sbCor) * [if (rightx > _leftx) 1 (-1)])
|
|
local fine : (_fine || Stroke) * 0.5
|
|
|
|
if stb : begin
|
|
local hst : HalfStroke * [diagCor (righty - lefty) (rightx - leftx) 0 HalfStroke]
|
|
local hse : HalfStroke * [Math.min 0.97 ([adviceBlackness 3.5] / Stroke)]
|
|
include : dispiro
|
|
corner leftx lefty [widths.heading hst hst [if (lefty < righty) Upward Downward]]
|
|
corner rightx righty [widths hse hse]
|
|
|
|
: else : begin
|
|
local height : Math.abs (lefty - righty)
|
|
local slabClearance : if slab [adviceBlackness2 3 2 height] 0
|
|
local turnyleft : mix lefty righty [if slab [Math.max turn (slabClearance / height)] turn]
|
|
local cyleft : mix turnyleft righty tension
|
|
local straightxleft : mix leftx rightx pStraight
|
|
local straightyleft : mix cyleft righty pStraight
|
|
include : dispiro
|
|
widths.center
|
|
flat leftx lefty [heading [if (lefty < righty) Upward Downward]]
|
|
curl leftx turnyleft [heading [if (lefty < righty) Upward Downward]]
|
|
quadcontrols 0 ((cyleft - turnyleft) / (straightyleft - turnyleft)) 24
|
|
flat straightxleft straightyleft
|
|
curl rightx righty
|
|
|
|
define [XStrand stb slab _leftx lefty _rightx righty turn pStraight tension] : glyph-construction
|
|
local middlex : mix _leftx _rightx 0.5
|
|
local middley : mix lefty righty 0.5
|
|
|
|
include : HalfXStrand stb slab _leftx lefty middlex middley turn pStraight tension
|
|
include : HalfXStrand stb slab _rightx righty middlex middley turn pStraight tension
|
|
|
|
sketch # X
|
|
set-width Width
|
|
include MarkSet.capital
|
|
|
|
branch
|
|
include : WithAIHSerifsMask CAP 0 SB RightSB : union
|
|
XStrand true SLAB SB 0 RightSB CAP 0.1 0.4 0.28
|
|
XStrand true SLAB SB CAP RightSB 0 0.1 0.4 0.28
|
|
include : AIHSerifs CAP
|
|
save 'X.straight' 'X'
|
|
save 'Chi.straight' 0x3A7
|
|
save 'cyrHa.straight' 0x425
|
|
branch
|
|
include : CyrDescender RightSB (connex -- 0.5)
|
|
save 'cyrHadescender.straight'
|
|
|
|
branch
|
|
include : WithAIHSerifsMask CAP 0 SB RightSB : union
|
|
XStrand false SLAB SB 0 RightSB CAP 0.1 0.4 0.28
|
|
XStrand false SLAB SB CAP RightSB 0 0.1 0.4 0.28
|
|
include : AIHSerifs CAP
|
|
save 'X.curly' 'X'
|
|
save 'Chi.curly' 0x3A7
|
|
save 'cyrHa.curly' 0x425
|
|
branch
|
|
include : CyrDescender RightSB
|
|
save 'cyrHadescender.curly'
|
|
|
|
sketch # x
|
|
include MarkSet.e
|
|
local turn : if SLAB 0.1 0.1
|
|
local tension : if SLAB 0.24 0.24
|
|
|
|
branch
|
|
include : WithAIHSerifsMask XH 0 SB RightSB : union
|
|
XStrand true SLAB SB 0 RightSB XH turn 0.4 tension
|
|
XStrand true SLAB SB XH RightSB 0 turn 0.4 tension
|
|
include : AIHSerifs XH
|
|
save 'x.straight' 'x'
|
|
save 'cyrha.straight' 0x445
|
|
branch
|
|
include : CyrDescender RightSB (connex -- 0.5)
|
|
save 'cyrhadescender.straight'
|
|
branch
|
|
include : WithAIHSerifsMask XH 0 SB RightSB : union
|
|
XStrand false SLAB SB 0 RightSB XH turn 0.4 tension
|
|
XStrand false SLAB SB XH RightSB 0 turn 0.4 tension
|
|
include : AIHSerifs XH
|
|
save 'x.curly' 'x'
|
|
save 'cyrha.curly' 0x445
|
|
branch
|
|
include : CyrDescender RightSB
|
|
save 'cyrhadescender.curly'
|
|
|
|
sketch # chi
|
|
set-width Width
|
|
include MarkSet.p
|
|
|
|
branch
|
|
include : union
|
|
XStrand true false SB Descender RightSB XH 0.05 0.4 0.11
|
|
XStrand true false SB XH RightSB Descender 0.05 0.4 0.11
|
|
save 'chi.straight'
|
|
save 'latinchi.straight'
|
|
branch
|
|
include : union
|
|
XStrand false false SB Descender RightSB XH 0.05 0.4 0.11
|
|
XStrand false false SB XH RightSB Descender 0.05 0.4 0.11
|
|
save 'chi.curly'
|
|
save 'latinchi.curly'
|
|
|
|
select-variant 'X' 'X'
|
|
select-variant 'Chi' 0x3A7 (follow -- 'X')
|
|
select-variant 'cyrHa' 0x425 (follow -- 'X')
|
|
select-variant 'cyrHadescender' 0x4B2 (follow -- 'X')
|
|
select-variant 'x' 'x'
|
|
select-variant 'cyrha' 0x445 (follow -- 'x')
|
|
select-variant 'chi' 0x3C7 (follow -- 'x')
|
|
select-variant 'latinchi' 0xAB53 (follow -- 'x')
|
|
select-variant 'cyrhadescender' 0x4B3 (follow -- 'x')
|
|
|
|
glyph-block Letter-Latin-Upper-Y : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-X : HalfXStrand
|
|
|
|
define [YShape straightBar top bot] : glyph-construction
|
|
local cross : mix [fallback bot 0] top 0.4
|
|
include : WithAIHSerifsMask CAP 0 SB RightSB
|
|
HalfXStrand straightBar SLAB SB top Middle cross 0.1 0.4 0.28
|
|
include : tagged 'strokeRT' : WithAIHSerifsMask CAP 0 SB RightSB
|
|
HalfXStrand straightBar SLAB RightSB top Middle cross 0.1 0.4 0.28
|
|
include : VBar Middle [fallback bot 0] (cross + HalfStroke)
|
|
set-base-anchor 'overlay' Middle cross
|
|
if SLAB : begin
|
|
include : AIVSerifs top
|
|
include : CenterBottomSerif Middle [fallback bot 0] MidJutSide
|
|
|
|
define [YOverlayShape] : glyph-construction
|
|
include : HOverlayBar SB RightSB (CAP * 0.45)
|
|
include : HOverlayBar SB RightSB (CAP * 0.25)
|
|
|
|
sketch # Y
|
|
include MarkSet.capital
|
|
branch
|
|
include : YShape true CAP
|
|
save 'Y.straight'
|
|
save 'Upsilon.straight'
|
|
save 'cyrUe.straight'
|
|
branch
|
|
include : YOverlayShape
|
|
save 'symbol/currency/yenSign.straight'
|
|
branch
|
|
include : YShape false CAP
|
|
save 'Y.curly'
|
|
save 'Upsilon.curly'
|
|
save 'cyrUe.curly'
|
|
branch
|
|
include : YOverlayShape
|
|
save 'symbol/currency/yenSign.curly'
|
|
|
|
define [YHookTopShape straightBar] : glyph-construction
|
|
include : YShape straightBar CAP
|
|
eject-contour 'strokeRT'
|
|
eject-contour 'serifRT'
|
|
|
|
local cross (CAP * 0.4)
|
|
include : dispiro
|
|
widths.rhs
|
|
straight.left.start (RightSB + HookX / 3) (CAP - Stroke)
|
|
g4 (RightSB - HookX / 3) (CAP - Hook)
|
|
quadcontrols 0.55 0.7 32 unimportant
|
|
g4 (Middle + Stroke / 2 * HVContrast) cross
|
|
end [function : set this.loose true]
|
|
|
|
sketch # Yhooktop
|
|
include MarkSet.capital
|
|
branch
|
|
include : YHookTopShape true
|
|
save 'Yhooktop.straight'
|
|
branch
|
|
include : YHookTopShape false
|
|
save 'Yhooktop.curly'
|
|
|
|
sketch # cyrue
|
|
include MarkSet.p
|
|
branch
|
|
include : YShape true XH Descender
|
|
save 'cyrue.straight'
|
|
branch
|
|
include : YShape false XH Descender
|
|
save 'cyrue.curly'
|
|
|
|
sketch # smcpY
|
|
include MarkSet.e
|
|
branch
|
|
include : YShape true XH
|
|
save 'smcpY.straight'
|
|
branch
|
|
include : YShape true XH
|
|
save 'smcpY.curly'
|
|
|
|
select-variant 'Y' 'Y'
|
|
select-variant 'Yhooktop' 0x1B3 (follow -- 'Y')
|
|
select-variant 'smcpY' 0x28F (follow -- 'Y')
|
|
select-variant 'Upsilon' 0x3A5 (follow -- 'Y')
|
|
select-variant 'cyrUe' 0x4AE (follow -- 'Y')
|
|
select-variant 'cyrue' 0x4AF (follow -- 'Y')
|
|
select-variant 'symbol/currency/yenSign' 0xA5 (follow -- 'Y')
|
|
|
|
glyph-block Letter-Latin-Lower-Y : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [GenSmallYShape straightBar useTurnBottom serifless] : begin
|
|
local slab : if serifless false SLAB
|
|
local useStraightBottom : straightBar && !useTurnBottom
|
|
local slabCurly : slab && !straightBar
|
|
local px1 0.84
|
|
local py1 : [StrokeWidthBlend 0.8 0.76] * [if slabCurly [StrokeWidthBlend 1 0.9] 1]
|
|
local px2 0.95
|
|
local py20 : 0.88 * [if slabCurly [StrokeWidthBlend 1 0.9] 1]
|
|
local py2 : if (useStraightBottom || useTurnBottom) 0.97 py20
|
|
local pds 0.1
|
|
local pds2 0.01
|
|
local dpy1 : (1 - [linreg (1 - px2) (1 - py2) px1 py1 1]) / (1 - py1)
|
|
local dpy20 : (1 - [linreg (1 - px1) (1 - py1) px2 py20 1]) / (1 - py20)
|
|
local dpy2 : (1 - [linreg (1 - px1) (1 - py1) px2 py2 1]) / (1 - py2)
|
|
local yrstrokel0 : Middle - Width * 0.1
|
|
local yrstrokel : Middle - Width * 0.1 + (Stroke * HVContrast * [if (useStraightBottom || useTurnBottom) (2 / 3) (1 / 3)] * [if slabCurly [StrokeWidthBlend 0.95 0.97] 1])
|
|
local yrstroker : Width - SB * [if (straightBar && SLAB && !slab) 1.5 1] * [if straightBar designParameters.straightSmallYShapeSbShrink 1]
|
|
local yshrink : [StrokeWidthBlend 1 0.85] * [if straightBar ([adviceBlackness 3.25] / Stroke) 1]
|
|
local yBottomJut : Jut * 1.25
|
|
local slabysize : Jut * 1.0625 * (Width / UPM) + Stroke
|
|
local slabyvx 0.7
|
|
|
|
define [CalcDS top bottom] : begin
|
|
local ds0 : (top - bottom) * pds
|
|
local ds : if slabCurly [Math.max [adviceBlackness2 3 6 (top - bottom)] ds0] ds0
|
|
local ds2 : (top - bottom) * pds2 + [if (useStraightBottom || useTurnBottom) (slabysize * slabyvx) 0]
|
|
return {ds ds2}
|
|
|
|
define [yDiagCor dy] : diagCor dy (yrstroker - yrstrokel) 0 Stroke
|
|
|
|
define [yTopKnots x top bottom ds dir] : begin
|
|
local hs : HalfStroke * [if straightBar [yDiagCor (top - bottom)] 1]
|
|
local hl : hs - hs * dir
|
|
local hr : hs + hs * dir
|
|
if straightBar : return : list
|
|
flat x top [widths.heading hl hr Downward]
|
|
: else : return : list
|
|
flat x top [widths.heading hl hr Downward]
|
|
curl x (top - ds) [widths.heading hl hr Downward]
|
|
quadcontrols 0 dpy1 16
|
|
|
|
define [yBaseKnots top bottom shrink hooktop] : begin
|
|
local {ds ds2} : CalcDS top bottom
|
|
define joinX : mix yrstrokel yrstroker (1 - px2)
|
|
define joinY : mix (bottom + ds2) (top - ds) (1 - py2)
|
|
define [ConnectZ shrink] : curl joinX joinY [widths.rhs : Stroke * shrink]
|
|
return : list
|
|
if (straightBar && (! hooktop))
|
|
then : list
|
|
else : list
|
|
flat
|
|
mix yrstrokel yrstroker px1
|
|
mix (bottom + ds2) (top - ds) py1
|
|
|
|
piecewise
|
|
useStraightBottom : list
|
|
ConnectZ shrink
|
|
curl [mix yrstroker joinX ((top - bottom) / (top - joinY))] bottom [widths.heading 0 (Stroke * [yDiagCor (top - bottom)]) Downward]
|
|
useTurnBottom : list
|
|
ConnectZ shrink
|
|
flat (yrstrokel - slabysize) bottom [widths.rhs]
|
|
curl [Math.min (yrstrokel - slabysize - 0.1) (yrstrokel - Stroke - yBottomJut)] bottom
|
|
true : list
|
|
ConnectZ 1
|
|
quadcontrols 1 (1 - dpy2) 16
|
|
flat yrstrokel (bottom + ds2) [widths.heading 0 Stroke Downward]
|
|
curl yrstrokel bottom [widths.heading 0 Stroke Downward]
|
|
|
|
define [yBaseSerif top bottom] : glyph-construction
|
|
local {ds ds2} : CalcDS top bottom
|
|
define joinX : mix yrstrokel yrstroker (1 - px2)
|
|
define joinY : mix (bottom + ds2) (top - ds) (1 - py2)
|
|
|
|
if (!useTurnBottom) : begin
|
|
if (useStraightBottom) : begin
|
|
local xBaseKnot : mix yrstroker joinX ((top - bottom) / (top - joinY))
|
|
include : LeftwardBottomSerif (xBaseKnot - HalfStroke * HVContrast) bottom yBottomJut
|
|
: else : begin
|
|
include : LeftwardBottomSerif (yrstroker - HalfStroke * HVContrast) bottom yBottomJut
|
|
|
|
define [yJoinProportion hooktop x] : linreg
|
|
1 - px2
|
|
1 - py2
|
|
if (straightBar && !hooktop) 1 px1
|
|
if (straightBar && !hooktop) 1 py1
|
|
(x - yrstrokel) / (yrstroker - yrstrokel)
|
|
|
|
define [yJoinHeight ds ds2 top bottom hooktop] : begin
|
|
return : mix (bottom + ds2) (top - ds) [yJoinProportion hooktop Middle]
|
|
|
|
define [yJoinKnots ds ds2 top bottom hooktop] : begin
|
|
return : list
|
|
if straightBar : then : list
|
|
: else : list
|
|
flat
|
|
mix (Width - yrstrokel) (Width - yrstroker) px1
|
|
mix (bottom + ds2) (top - ds) py1
|
|
curl Middle
|
|
yJoinHeight ds ds2 top bottom hooktop
|
|
widths.lhs (Stroke * yshrink)
|
|
|
|
define [SmallYStrokeSplitMask top bottom hooktop dir elev] : begin
|
|
local {ds ds2} : CalcDS top bottom
|
|
local jp0 : yJoinProportion hooktop (Width / 2 - Width / 2 * dir)
|
|
local jp1 : yJoinProportion hooktop (Width / 2 + Width / 2 * dir)
|
|
local hs : 0.75 * Stroke
|
|
local yLeft : [mix (bottom + ds2) (top - ds) jp1] + hs - [fallback elev 0]
|
|
local yRight : [mix (bottom + ds2) (top - ds) jp0] + hs - [fallback elev 0]
|
|
local yMin : Math.min bottom yLeft yRight
|
|
return : spiro-outline
|
|
corner Width yMin
|
|
corner Width yRight
|
|
corner 0 yLeft
|
|
corner 0 yMin
|
|
|
|
define [SmallYShape top bottom] : glyph-construction
|
|
local {ds ds2} : CalcDS top bottom
|
|
|
|
include : intersection
|
|
SmallYStrokeSplitMask top bottom false 1
|
|
dispiro
|
|
yTopKnots yrstroker top bottom ds 1
|
|
yBaseKnots top bottom 1
|
|
|
|
include : difference
|
|
dispiro
|
|
yTopKnots yrstroker top bottom ds 1
|
|
yBaseKnots top bottom yshrink
|
|
SmallYStrokeSplitMask top bottom false 1 1
|
|
|
|
include : difference
|
|
dispiro
|
|
yTopKnots (Width - yrstroker) top bottom ds (-1)
|
|
yJoinKnots ds ds2 top bottom
|
|
SmallYStrokeSplitMask top bottom false (-1)
|
|
Rect (bottom + HalfStroke) (bottom - top) 0 Width
|
|
|
|
if slab : begin
|
|
include : AIVSerifs top
|
|
include : yBaseSerif top bottom
|
|
|
|
define [SmallYHookTopShape top bottom] : glyph-construction
|
|
local ds : (top - bottom) * pds
|
|
local ds2 : (top - bottom) * pds2 + [if (useStraightBottom || useTurnBottom) (slabysize * slabyvx) 0]
|
|
local joinHeight : yJoinHeight ds ds2 top bottom true
|
|
|
|
include : intersection
|
|
SmallYStrokeSplitMask top bottom true 1
|
|
dispiro
|
|
widths.rhs
|
|
straight.left.start ([mix yrstrokel yrstroker px1] - HalfStroke + HookX) (XH - Stroke)
|
|
yBaseKnots top bottom 1 true
|
|
|
|
include : difference
|
|
dispiro
|
|
widths.rhs
|
|
straight.left.start ([mix yrstrokel yrstroker px1] - HalfStroke + HookX) (XH - Stroke)
|
|
yBaseKnots top bottom yshrink true
|
|
SmallYStrokeSplitMask top bottom true 1 1
|
|
|
|
include : difference
|
|
dispiro
|
|
widths.center
|
|
yTopKnots (Width - yrstroker) top bottom ds (-1)
|
|
yJoinKnots ds ds2 top bottom true
|
|
SmallYStrokeSplitMask top bottom true (-1)
|
|
|
|
if slab : begin
|
|
include : AIVSerifs top
|
|
eject-contour 'serifRT'
|
|
include : yBaseSerif top bottom
|
|
|
|
define [SmallLambdaShape top bottom] : ReverseContours : glyph-construction
|
|
set currentGlyph.gizmo : Italify (-para.slantAngle)
|
|
include : SmallYShape top bottom
|
|
set currentGlyph.gizmo : Italify (+para.slantAngle)
|
|
# apply-transform : Upright
|
|
apply-transform : Translate 0 (-[mix bottom top 0.5])
|
|
apply-transform : Scale 1 (-1)
|
|
apply-transform : Translate 0 (+[mix bottom top 0.5])
|
|
# apply-transform : Italify
|
|
|
|
return : object SmallYShape SmallYHookTopShape SmallLambdaShape
|
|
|
|
sketch # y.straight
|
|
include MarkSet.p
|
|
branch
|
|
include : [GenSmallYShape true false].SmallYShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'y.straight'
|
|
save 'cyru.straight'
|
|
branch
|
|
include : [GenSmallYShape true true].SmallYShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'y.straightTurn'
|
|
save 'cyru.straightTurn'
|
|
branch
|
|
include : [GenSmallYShape false SLAB].SmallYShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'y.curly'
|
|
save 'cyru.curly'
|
|
|
|
sketch # y.cursive
|
|
include MarkSet.p
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
fine -- ShoulderFine
|
|
include : FlipAround Middle (XH / 2)
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RightSB XH [heading Downward]
|
|
curl RightSB (Descender + SmallSmoothA)
|
|
hookend (Descender + O)
|
|
g4 SB (Descender + SHook)
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif SB XH SideJut
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'y.cursive'
|
|
save 'cyru.cursive'
|
|
|
|
select-variant 'y' 'y'
|
|
select-variant 'cyru' 0x443 (follow -- 'y')
|
|
|
|
|
|
sketch # yhooktop
|
|
include MarkSet.p
|
|
branch
|
|
include : [GenSmallYShape true false].SmallYHookTopShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'yhooktop.straight'
|
|
branch
|
|
include : [GenSmallYShape true true].SmallYHookTopShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'yhooktop.straightTurn'
|
|
branch
|
|
include : [GenSmallYShape false SLAB].SmallYHookTopShape XH Descender
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'yhooktop.curly'
|
|
|
|
sketch # y.cursive
|
|
include MarkSet.p
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
fine -- ShoulderFine
|
|
include : FlipAround Middle (XH / 2)
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RightSB (XH - Hook - HalfStroke) [heading Downward]
|
|
curl RightSB (Descender + SmallSmoothA)
|
|
hookend (Descender + O)
|
|
g4 SB (Descender + SHook)
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) (XH - Hook - HalfStroke) HookX (-Hook)
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif SB XH SideJut
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'yhooktop.cursive'
|
|
|
|
sketch # cyrU
|
|
include MarkSet.capital
|
|
branch
|
|
include : [GenSmallYShape true false].SmallYShape CAP 0
|
|
set-base-anchor 'overlay' Middle (XH / 2 - Descender)
|
|
save 'cyrU.straight'
|
|
branch
|
|
include : [GenSmallYShape true true].SmallYShape CAP 0
|
|
set-base-anchor 'overlay' Middle (XH / 2 - Descender)
|
|
save 'cyrU.straightTurn'
|
|
branch
|
|
include : [GenSmallYShape false SLAB].SmallYShape CAP 0
|
|
set-base-anchor 'overlay' Middle (XH / 2 - Descender)
|
|
save 'cyrU.curly'
|
|
|
|
select-variant 'yhooktop' 0x1B4 (follow -- 'y')
|
|
select-variant 'cyrU' 0x423 (omit -- {.v-y-cursive true .cv49 true})
|
|
|
|
turned 'turny' 0x28E 'y' Middle (XH / 2) MarkSet.b
|
|
|
|
define [LambdaBarOverlayShape] : FlatSlashShape [mix SB RightSB 0.45] [mix 0 CAP 0.8] (OverlayStroke / 2)
|
|
|
|
sketch # lambda.straight
|
|
include MarkSet.b
|
|
include : [GenSmallYShape true false true].SmallLambdaShape CAP 0
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'lambda.straight'
|
|
include : LambdaBarOverlayShape
|
|
save 'lambdaSlash.straight'
|
|
|
|
sketch # lambda.curly
|
|
include MarkSet.b
|
|
include : [GenSmallYShape false false true].SmallLambdaShape CAP 0
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'lambda.curly'
|
|
include : LambdaBarOverlayShape
|
|
save 'lambdaSlash.curly'
|
|
|
|
select-variant 'lambda' 0x3BB
|
|
select-variant 'lambdaSlash' 0x19B (follow -- 'lambda')
|
|
|
|
|
|
glyph-block Letter-Latin-K : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
|
|
local [KBalance straightBar] : if SLAB (Width / 16) : if straightBar (Width / 32) 0
|
|
local [KBalanceRight straightBar] : if SLAB (-Width / 32) : if straightBar (Width / 32) 0
|
|
local [KBalanceRightCursive straightBar] : if SLAB (Width / 16) : if straightBar (Width / 32) 0
|
|
local [KO straightBar top stroke] : if straightBar (([if SLAB (0) (-4)] * OX - stroke / 3) * (XH / top)) 0
|
|
|
|
define [KLegShape left right top straightBar _stroke] : glyph-construction
|
|
local stroke : fallback _stroke Stroke
|
|
local turn (top * 0.99)
|
|
local fine : adviceBlackness 3.5
|
|
local Ok : KO straightBar top stroke
|
|
local kshLeft : left + [KBalance straightBar]
|
|
local kshRight : right + [KBalanceRight straightBar]
|
|
|
|
if straightBar : do
|
|
local attach (top * 0.42 - stroke)
|
|
local attach2 (top * 0.72 + stroke)
|
|
include : intersection
|
|
Rect top 0 0 UPM
|
|
dispiro
|
|
widths.rhs stroke
|
|
flat (kshRight - Ok) top
|
|
curl (kshLeft + stroke) attach [widths 0 fine]
|
|
|
|
include : intersection
|
|
spiro-outline
|
|
corner (kshLeft + stroke) 0
|
|
corner (kshLeft + stroke) (attach + 1)
|
|
corner (kshRight - Ok - 1) top
|
|
corner (kshRight - Ok) top
|
|
corner (kshRight - Ok) 0
|
|
dispiro
|
|
widths.lhs stroke
|
|
flat (kshRight - Ok) 0
|
|
curl (kshLeft + stroke) attach2
|
|
: else : do
|
|
local attach (top * [if SLAB 0.325 0.375])
|
|
local attach2 [if SLAB [mix kshLeft kshRight 0.48] Middle]
|
|
include : dispiro
|
|
g4.down.start (kshRight) top [widths.heading 0 (stroke * [if SLAB 1.15 1.05] * (Width * 2 / UPM)) Downward]
|
|
bezcontrols 0 0.2 0.5 0.65 8
|
|
g4 (kshLeft + stroke) attach [widths 0 fine]
|
|
include : difference
|
|
dispiro
|
|
widths.center
|
|
g4.up.start (kshRight - O - stroke / 2 * HVContrast) 0 [heading Upward]
|
|
quadcontrols 0 0.25 8
|
|
g4 attach2 (top * 0.61) [widths.center fine]
|
|
spiro-outline
|
|
corner.down.start kshRight top
|
|
bezcontrols 0 0.2 0.5 0.65 8
|
|
corner (kshLeft + stroke) attach
|
|
corner kshLeft 0
|
|
corner kshLeft top
|
|
|
|
if SLAB : do
|
|
local topSerifX : kshRight - (stroke * [if SLAB 1.15 1.05] * (Width * 2 / UPM) / 2 - stroke / 2) * HVContrast * [if para.isItalic 1 0] - stroke / 2 * 0.5 * HVContrast
|
|
local bottomSerifX : kshRight - O * [if para.isItalic 1 0]
|
|
|
|
include : RightwardTopSerif topSerifX top (SideJut + stroke / 2 * 0.5 * HVContrast)
|
|
include : RightwardBottomSerif bottomSerifX 0 SideJut
|
|
|
|
define [KCurlyLoopAndLegShape top straightBar] : glyph-construction
|
|
define kshLeft : SB + [KBalance straightBar]
|
|
define kshRight : RightSB + [KBalanceRightCursive straightBar] + 0.2 * Stroke
|
|
|
|
define arcFine ShoulderFine
|
|
define arcStroke : adviceBlackness2 2 3 top
|
|
define arcTerminalFine : adviceBlackness2 3 4 top
|
|
define st : shoulderMidSlope arcFine arcStroke 1
|
|
|
|
define arcMaxPropX : 0.8 + 2 * (arcStroke / Width)
|
|
define startPropY : 0.46 + 0.1 * (arcStroke / Width)
|
|
define arcTopPropX : 0.56 + 0.2 * (arcStroke / Width)
|
|
define arcMaxXPropY : 0.6 - 1 * (arcStroke / Width)
|
|
define arcEndPropX : 0.15 - 0.5 * (arcStroke / Width)
|
|
define arcEndPropY : 0.45 + 0.2 * (arcStroke / Width)
|
|
|
|
define arcStartX : kshLeft + HVContrast * (Stroke - arcFine)
|
|
define arcMaxX : kshRight * 0.9
|
|
define arcTopY : top - O
|
|
|
|
define arcTerminalX : mix arcStartX kshRight arcEndPropX
|
|
define arcTerminalY : mix 0 top arcEndPropY
|
|
|
|
include : difference
|
|
dispiro
|
|
g2.up.start arcStartX (top * startPropY) [widths.heading 0 arcFine Upward]
|
|
arcvh
|
|
g2.right.mid [mix arcStartX arcMaxX arcTopPropX] arcTopY [widths.heading 0 arcStroke {.y (+1) .x (+st)}]
|
|
archv
|
|
g2.down.mid arcMaxX [mix arcTerminalY top arcMaxXPropY] [heading Downward]
|
|
quadcontrols 0 0.7
|
|
g2 arcTerminalX arcTerminalY [widths arcTerminalFine 0]
|
|
spiro-outline
|
|
corner 0 0
|
|
corner 0 arcTerminalY
|
|
corner arcTerminalX arcTerminalY
|
|
corner kshRight 0
|
|
|
|
include : intersection
|
|
Rect [mix 0 top arcEndPropY] 0 0 UPM
|
|
dispiro
|
|
flat arcTerminalX arcTerminalY [widths.lhs]
|
|
curl kshRight 0 [widths.rhs]
|
|
|
|
define [KShape straightBar] : glyph-construction
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 CAP
|
|
include : KLegShape SB RightSB CAP straightBar
|
|
if SLAB : begin
|
|
include : CenterTopSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) CAP Jut
|
|
include : CenterBottomSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) 0 Jut
|
|
|
|
sketch # K
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : KShape true
|
|
branch
|
|
save 'K.straight'
|
|
save 'Kappa.straight'
|
|
save 'cyrKa.straight'
|
|
branch
|
|
include : CyrDescender (RightSB + [KBalanceRight true] - [KO true CAP Stroke]) (connex -- 1)
|
|
save 'cyrKaDescender.straight'
|
|
|
|
sketch # K
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : KShape false
|
|
branch
|
|
save 'K.curly'
|
|
save 'Kappa.curly'
|
|
save 'cyrKa.curly'
|
|
branch
|
|
include : CyrDescender (RightSB + [KBalanceRight false] - [KO false CAP Stroke])
|
|
save 'cyrKaDescender.curly'
|
|
|
|
select-variant 'K' 'K'
|
|
select-variant 'Kappa' 0x39A (follow -- 'K')
|
|
select-variant 'cyrKa' 0x41A (follow -- 'K')
|
|
select-variant 'cyrKaDescender' 0x49A (follow -- 'K')
|
|
|
|
define [LowerKShape straightBar] : glyph-construction
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 CAP
|
|
include : KLegShape SB RightSB XH straightBar
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (SB + [KBalance straightBar]) CAP SideJut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB'
|
|
CenterBottomSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) 0 Jut
|
|
|
|
define [LowerKCursiveShape straightBar] : glyph-construction
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 CAP
|
|
include : KCurlyLoopAndLegShape XH straightBar
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (SB + [KBalance straightBar]) CAP SideJut
|
|
|
|
sketch # k.straight
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : LowerKShape true
|
|
save 'k.straight'
|
|
|
|
sketch # k.curly
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : LowerKShape false
|
|
save 'k.curly'
|
|
|
|
sketch # k
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : LowerKCursiveShape true
|
|
save 'k.cursive'
|
|
|
|
select-variant 'k' 'k'
|
|
|
|
define [LowerKappaShape straightBar] : glyph-construction
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 XH
|
|
include : KLegShape SB RightSB XH straightBar
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (SB + [KBalance straightBar]) XH SideJut
|
|
|
|
sketch # kappa
|
|
set-width Width
|
|
include MarkSet.e
|
|
include : LowerKappaShape true
|
|
save 'kappa.straight'
|
|
|
|
sketch # kappa
|
|
set-width Width
|
|
include MarkSet.e
|
|
include : LowerKappaShape false
|
|
save 'kappa.curly'
|
|
|
|
select-variant 'kappa' 0x3BA (follow -- 'K')
|
|
|
|
define [LowerCyrKaShape straightBar] : glyph-construction
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 XH
|
|
include : KLegShape SB RightSB XH straightBar
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) 0 Jut
|
|
include : CenterTopSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) XH Jut
|
|
|
|
sketch # cyrka
|
|
set-width Width
|
|
include MarkSet.e
|
|
include : LowerCyrKaShape true
|
|
branch
|
|
save 'cyrka.straight'
|
|
save 'latinkappa.straight'
|
|
branch
|
|
include : CyrDescender (RightSB + [KBalanceRight true] - [KO true XH Stroke]) (connex -- 1)
|
|
save 'cyrkaDescender.straight'
|
|
|
|
sketch # cyrka
|
|
set-width Width
|
|
include MarkSet.e
|
|
include : LowerCyrKaShape false
|
|
branch
|
|
save 'cyrka.curly'
|
|
save 'latinkappa.curly'
|
|
branch
|
|
include : CyrDescender (RightSB + [KBalanceRight false] - [KO false XH Stroke])
|
|
save 'cyrkaDescender.curly'
|
|
|
|
select-variant 'cyrka' 0x43A (follow -- 'K')
|
|
select-variant 'latinkappa' 0x138 (follow -- 'K')
|
|
select-variant 'cyrkaDescender' 0x49B (follow -- 'K')
|
|
|
|
define [KHookTopShape straightBar] : glyph-construction
|
|
include : KLegShape SB RightSB CAP straightBar
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 (CAP - Hook - HalfStroke)
|
|
include : VerticalHook (SB + [KBalance straightBar] + HalfStroke * HVContrast) (CAP - Hook - HalfStroke) HookX (-Hook)
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) 0 Jut
|
|
|
|
sketch # Khooktop
|
|
include MarkSet.capital
|
|
include : KHookTopShape true
|
|
save 'Khooktop.straight'
|
|
sketch # Khooktop
|
|
include MarkSet.capital
|
|
include : KHookTopShape false
|
|
save 'Khooktop.curly'
|
|
select-variant 'Khooktop' 0x198 (follow -- 'K')
|
|
|
|
define [LowerKHookTopShape straightBar] : glyph-construction
|
|
include : KLegShape SB RightSB XH straightBar
|
|
include : VBarLeft (SB + [KBalance straightBar]) 0 (CAP - Hook - HalfStroke)
|
|
include : VerticalHook (SB + [KBalance straightBar] + HalfStroke * HVContrast) (CAP - Hook - HalfStroke) HookX (-Hook)
|
|
if (SLAB && !para.isItalic) : begin
|
|
include : tagged 'serifLB'
|
|
CenterBottomSerif (SB + [KBalance straightBar] + HalfStroke * HVContrast) 0 Jut
|
|
|
|
sketch # khooktop.straight
|
|
include MarkSet.b
|
|
include : LowerKHookTopShape true
|
|
save 'khooktop.straight'
|
|
sketch # khooktop.curly
|
|
include MarkSet.b
|
|
include : LowerKHookTopShape false
|
|
save 'khooktop.curly'
|
|
select-variant 'khooktop' 0x199 (follow -- 'K')
|
|
|
|
turned 'turnK.straight' nothing 'K.straight' Middle (CAP / 2)
|
|
turned 'turnK.curly' nothing 'K.curly' Middle (CAP / 2)
|
|
select-variant 'turnK' 0xA7B0 (follow -- 'K')
|
|
|
|
turned 'turnk.straight' nothing 'k.straight' Middle (XH / 2) MarkSet.p
|
|
turned 'turnk.curly' nothing 'k.curly' Middle (XH / 2) MarkSet.p
|
|
turned 'turnk.cursive' nothing 'k.cursive' Middle (XH / 2) MarkSet.p
|
|
select-variant 'turnk' 0x29E (follow -- 'k')
|
|
|
|
define [BashkirKaShape top straightBar] : glyph-construction
|
|
local left : if SLAB ([mix SB RightSB 0.35] - MVertStroke / 2 * HVContrast) [mix SB RightSB 0.2]
|
|
local leftNB : left - [KBalance straightBar]
|
|
local barleft : mix 0 SB [if SLAB 0.25 0.375]
|
|
local sw : adviceBlackness 3
|
|
|
|
include : HBarTop barleft (Stroke * 0.1 + left) top
|
|
include : VBarLeft left 0 top sw
|
|
include : KLegShape leftNB RightSB top straightBar sw
|
|
if SLAB : begin
|
|
include : CenterBottomSerif (left + HalfStroke * HVContrast) 0 Jut
|
|
include : DownwardLeftSerif barleft top VJut (MVertStroke / HVContrast)
|
|
sketch # cyrBashkirUpperKa.straight
|
|
include MarkSet.capital
|
|
include : BashkirKaShape CAP true
|
|
save 'cyrBashkirUpperKa.straight'
|
|
sketch # cyrBashkirUpperKa.curly
|
|
include MarkSet.capital
|
|
include : BashkirKaShape CAP false
|
|
save 'cyrBashkirUpperKa.curly'
|
|
sketch # cyrBashkirKa.straight
|
|
include MarkSet.e
|
|
include : BashkirKaShape XH true
|
|
save 'cyrBashkirKa.straight'
|
|
sketch # cyrBashkirKa.curly
|
|
include MarkSet.e
|
|
include : BashkirKaShape XH false
|
|
save 'cyrBashkirKa.curly'
|
|
|
|
select-variant 'cyrBashkirUpperKa' 0x4A0 (follow -- 'K')
|
|
select-variant 'cyrBashkirKa' 0x4A1 (follow -- 'K')
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-B : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [BShape] : params [top [barPos 0.52] [topArcShift 0] [topArcInnerShift 0]] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 2 top
|
|
local bowl : top * barPos + stroke * (1 - barPos)
|
|
local barleft SB
|
|
local curvleft : RightSB - SB * 0.5 - (top - (bowl - stroke)) * 0.45 + topArcInnerShift
|
|
local curvleftTop : Math.min curvleft (RightSB - SB * 0.5 - OX - stroke * 1.375 + topArcInnerShift)
|
|
local xTopArcRight : [mix SB RightSB 0.93] - OX * 2 + topArcShift
|
|
local fine : stroke * CThin
|
|
|
|
local sma : SmoothAOf (Smooth * 0.9) Width
|
|
local smb : SmoothBOf (Smooth * 0.9) Width
|
|
local smaTop : SmoothAOf (Smooth * 0.9 - (curvleft - curvleftTop)) Width
|
|
local smbTop : SmoothBOf (Smooth * 0.9 - (curvleft - curvleftTop)) Width
|
|
|
|
include : dispiro
|
|
widths.rhs stroke
|
|
flat (barleft - O) top [heading Rightward]
|
|
curl (curvleftTop - CorrectionOMidS) top
|
|
archv
|
|
straight.down.mid xTopArcRight [mix top (bowl - stroke) (smbTop / (smaTop + smbTop))]
|
|
arcvh
|
|
flat (curvleftTop + CorrectionOMidS) (bowl - fine) [widths.rhs fine]
|
|
curl (barleft - O) (bowl - fine) [heading Leftward]
|
|
|
|
include : dispiro
|
|
widths.rhs fine
|
|
flat (barleft - O) (bowl - stroke + fine) [heading Rightward]
|
|
curl (curvleft - CorrectionOMidS) (bowl - stroke + fine)
|
|
archv
|
|
straight.down.mid (RightSB - OX * 2) [mix bowl 0 (smb / (sma + smb))] [widths.rhs stroke]
|
|
arcvh
|
|
flat (curvleft + CorrectionOMidS) 0
|
|
curl (barleft - O) 0 [heading Leftward]
|
|
|
|
include : VBarLeft barleft 0 top stroke
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif barleft top SideJut
|
|
include : tagged 'serifLB' : LeftwardBottomSerif barleft 0 SideJut
|
|
|
|
create-glyph 'B.standard' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : BShape CAP
|
|
|
|
create-glyph 'B.moreAsymmetric' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : BShape CAP (barPos -- 0.6) (topArcShift -- -(RightSB - SB) * 0.05) (topArcInnerShift -- -(RightSB - SB) * 0.1)
|
|
|
|
select-variant 'B' 'B'
|
|
alias 'Beta' 0x392 'B'
|
|
alias 'cyrVe' 0x412 'B'
|
|
|
|
sketch # Bhookleft
|
|
include [refer-glyph 'B'] AS_BASE
|
|
eject-contour "serifLT"
|
|
include : LeftHook SB CAP
|
|
|
|
save 'Bhookleft' 0x181
|
|
|
|
define [ItalicCyrveShape top] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 2 top
|
|
local mid : mix RightSB SB 0.65
|
|
local midy : top * HBarPos
|
|
local smb : top - [mix (midy + stroke / 2) (top - O - stroke) (SmoothA / (SmoothA + SmoothB))] + TanSlope * HVContrast * stroke
|
|
local sma : [mix (stroke + O) (midy - stroke / 2) (SmoothA / (SmoothA + SmoothB))] - TanSlope * HVContrast * stroke
|
|
local fine : stroke * CThin
|
|
include : dispiro
|
|
widths.lhs fine
|
|
flat mid (midy - (fine - stroke / 2)) [heading Rightward]
|
|
curl Middle (midy - (fine - stroke / 2)) [heading Rightward]
|
|
archv
|
|
g4 (RightSB - (OX - O)) (top - smb) [widths.lhs stroke]
|
|
arcvh
|
|
g4 (Middle + stroke * 0.06 - CorrectionOMidS) (top - O)
|
|
archv
|
|
flat (SB + O) (top - SmallSmoothA)
|
|
curl (SB + O) SmallSmoothB
|
|
arcvh
|
|
g4 (Middle + stroke * 0.06 + CorrectionOMidS) O
|
|
archv
|
|
g4 (RightSB - (OX - O) - O * 2) (sma)
|
|
arcvh
|
|
flat Middle (midy + (fine - stroke / 2)) [widths.heading fine 0 Leftward]
|
|
curl mid (midy + (fine - stroke / 2)) [widths.heading fine 0 Leftward]
|
|
|
|
define [ClosedEpsilonShape top] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 2 top
|
|
local mid : mix SB RightSB 0.65
|
|
local midy : top * HBarPos
|
|
local sma : top - [mix (midy + stroke / 2) (top - O - stroke) (SmoothB / (SmoothA + SmoothB))] - TanSlope * HVContrast * stroke
|
|
local smb : [mix (stroke + O) (midy - stroke / 2) (SmoothB / (SmoothA + SmoothB))] + TanSlope * HVContrast * stroke
|
|
local fine : stroke * CThin
|
|
include : dispiro
|
|
widths.rhs fine
|
|
flat mid (midy - (fine - stroke / 2)) [heading Leftward]
|
|
curl Middle (midy - (fine - stroke / 2)) [heading Leftward]
|
|
archv
|
|
g4 (SB + (OX - O)) (top - sma) [widths.rhs stroke]
|
|
arcvh
|
|
g4 (Middle - stroke * 0.06 - CorrectionOMidS) (top - O)
|
|
archv
|
|
flat (RightSB - O) (top - SmallSmoothB)
|
|
curl (RightSB - O) SmallSmoothA
|
|
arcvh
|
|
g4 (Middle - stroke * 0.06 + CorrectionOMidS) O
|
|
archv
|
|
g4 (SB + (OX - O) + O * 2) (smb)
|
|
arcvh
|
|
flat Middle (midy + (fine - stroke / 2)) [widths.heading 0 fine Rightward]
|
|
curl mid (midy + (fine - stroke / 2)) [widths.heading 0 fine Rightward]
|
|
|
|
sketch # cyrve.italic
|
|
include MarkSet.e
|
|
include : ItalicCyrveShape XH
|
|
save 'cyrve.italic'
|
|
save 'closeturnepsilon' 0x25E
|
|
|
|
sketch # cyrve.BGR
|
|
include MarkSet.e
|
|
include : ItalicCyrveShape CAP
|
|
save 'cyrve.BGR'
|
|
|
|
sketch # cyrve.upright
|
|
include MarkSet.e
|
|
include : BShape XH
|
|
save 'cyrve.upright'
|
|
save 'smcpB' 0x299
|
|
italic-variant 'cyrve' 0x432
|
|
|
|
sketch # closedepsilon
|
|
include MarkSet.e
|
|
include : ClosedEpsilonShape XH
|
|
save 'closeepsilon' 0x29A
|
|
|
|
sketch # Bbar
|
|
include [refer-glyph 'B'] AS_BASE
|
|
local stroke : adviceBlackness2 2.875 2 CAP
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.5] [mix 0 (CAP * 0.52 + stroke / 2) 0.5] [Math.min ((CAP - Stroke * 3) / 4) OverlayStroke]
|
|
save 'Bbar' 0x243
|
|
|
|
sketch # beta
|
|
include MarkSet.if
|
|
local ymiddle : [mix 0 CAP 0.55] - HalfStroke
|
|
local fine : Stroke * CThin
|
|
include : dispiro
|
|
widths.rhs
|
|
flat SB Descender [heading Upward]
|
|
curl SB (CAP - SmallSmoothA)
|
|
arcvh
|
|
g4 ([mix SB (RightSB - OX + O * 3) 0.5] - CorrectionOMidS) (CAP - O)
|
|
archv
|
|
g4 (RightSB - OX + O * 3) [mix CAP ymiddle 0.5]
|
|
arcvh
|
|
flat [mix SB (RightSB - OX + O * 3) 0.5] (ymiddle + Stroke - fine) [widths.rhs fine]
|
|
curl [mix SB RightSB 0.3] (ymiddle + Stroke - fine)
|
|
include : dispiro
|
|
widths.rhs fine
|
|
flat ([mix SB RightSB 0.3] - (2 * fine - Stroke) * TanSlope) (ymiddle + fine)
|
|
curl (RightSB - ymiddle / 2 - HalfStroke) (ymiddle + fine)
|
|
archv
|
|
g4 (RightSB - OX) [mix 0 (ymiddle + Stroke) 0.5] [widths.rhs]
|
|
arcvh
|
|
flat (RightSB - ymiddle / 2 - HalfStroke) 0
|
|
curl (SB + HalfStroke) 0 [heading Leftward]
|
|
save 'beta' 0x3B2
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-B : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # b
|
|
set-width Width
|
|
include MarkSet.b
|
|
|
|
include : OBarLeftShape
|
|
include : VBarLeft SB 0 CAP
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB CAP SideJut
|
|
include : tagged 'serifLB' : LeftwardBottomSerif SB 0 SideJut
|
|
|
|
save 'b' 'b'
|
|
|
|
sketch # bhooktop
|
|
include MarkSet.b
|
|
include : OBarLeftShape
|
|
include : HooktopLeftBar
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : LeftwardBottomSerif SB 0 SideJut
|
|
|
|
|
|
save 'bhooktop' 0x253
|
|
|
|
sketch # bbar
|
|
include [refer-glyph 'b'] AS_BASE
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.5] [mix XH CAP 0.45]
|
|
save 'bbar' 0x180
|
|
|
|
sketch # bdot
|
|
include : refer-glyph "dotAbove"
|
|
apply-transform : Translate (Width + HalfStroke) 0
|
|
include [refer-glyph 'b'] AS_BASE
|
|
save 'bdot' 0x1E03
|
|
|
|
sketch # latinbe
|
|
include [refer-glyph 'b'] AS_BASE
|
|
include : HBarTop (SB - O) [mix SB RightSB 0.9] CAP
|
|
if SLAB : begin
|
|
include : DownwardRightSerif [mix SB RightSB 0.9] CAP VJut
|
|
save 'latinbe' 0x183
|
|
|
|
sketch # zhuangtonesix
|
|
include [refer-glyph 'b'] AS_BASE
|
|
eject-contour 'serifLT'
|
|
local s : Math.max (XH * 0.1) Stroke
|
|
include : ReverseContours : spiro-outline
|
|
corner (SB - O) CAP
|
|
corner SB CAP
|
|
corner (SB - s) (CAP - s)
|
|
corner SB (CAP - s * 2)
|
|
corner (SB - O) (CAP - s * 2)
|
|
save 'zhuangtonesix' 0x185
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-D : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [DShape fRound] : glyph-construction
|
|
local barleft SB
|
|
include : VBarLeft barleft 0 CAP
|
|
|
|
local dsmooth : Math.min (CAP * 0.499) (Smooth * 1.1)
|
|
local bsmooth : Math.min (Width - SB * 2 - Stroke) (Smooth * 1.1)
|
|
local bsmoothRd : Math.min (Width - SB * 2 - Stroke) (Smooth * 1.25)
|
|
|
|
local sma : SmoothAOf dsmooth Width
|
|
local smb : SmoothBOf dsmooth Width
|
|
|
|
if (fRound) : include : dispiro
|
|
widths.rhs
|
|
flat (barleft - O) CAP [heading Rightward]
|
|
curl (RightSB - bsmoothRd - CorrectionOMidS) CAP
|
|
archv
|
|
straight.down.mid (RightSB - OX) [mix 0 CAP (sma / (sma + smb))]
|
|
arcvh
|
|
flat (RightSB - bsmoothRd + CorrectionOMidS) 0
|
|
curl (barleft - O) 0 [heading Leftward]
|
|
: else : include : dispiro
|
|
widths.rhs
|
|
flat (barleft - O) CAP [heading Rightward]
|
|
curl (RightSB - bsmooth - CorrectionOMidS) CAP
|
|
archv
|
|
flat (RightSB - OX) (CAP - smb)
|
|
curl (RightSB - OX) (0 + sma)
|
|
arcvh
|
|
flat (RightSB - bsmooth + CorrectionOMidS) 0
|
|
curl (barleft - O) 0 [heading Leftward]
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif barleft CAP SideJut
|
|
include : tagged 'serifLB' : LeftwardBottomSerif barleft 0 SideJut
|
|
|
|
create-glyph 'D.standard' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : DShape false
|
|
|
|
create-glyph 'D.moreRounded' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : DShape true
|
|
|
|
select-variant 'D' 'D'
|
|
|
|
WithDerivatives 'D' 'Eth' : lambda [src sel] : glyph-construction
|
|
if [not sel] : assign-unicode 0xD0
|
|
include [refer-glyph src] AS_BASE ALSO_METRICS
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + Stroke) (RightSB - Stroke) 0.55] (CAP * OverlayPos)
|
|
|
|
alias 'Dcroat' 0x110 'Eth'
|
|
alias 'arficanD' 0x189 'Eth'
|
|
|
|
WithDerivatives 'D' 'Dhookleft' : lambda [src sel] : glyph-construction
|
|
if [not sel] : assign-unicode 0x18a
|
|
include [refer-glyph src] AS_BASE ALSO_METRICS
|
|
eject-contour 'serifLT'
|
|
include : LeftHook SB CAP
|
|
|
|
glyph-block Letter-Latin-Lower-D : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # d
|
|
set-width Width
|
|
include MarkSet.b
|
|
|
|
include : OBarRightShape
|
|
include : VBarRight RightSB 0 CAP
|
|
if SLAB : begin
|
|
include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
include : LeftwardTopSerif (RightSB - Stroke * HVContrast) CAP SideJut
|
|
|
|
save 'd' 'd'
|
|
|
|
sketch # dcroat
|
|
include [refer-glyph 'd'] AS_BASE
|
|
include : HBar [mix (SB + Stroke) (RightSB - Stroke) 0.5] [mix RightSB Width 0.7] [mix XH CAP 0.45] OverlayStroke
|
|
|
|
save 'dcroat' 0x111
|
|
|
|
sketch # dcaron
|
|
include : refer-glyph "commaAbove"
|
|
apply-transform : Translate (Width + (RightSB - SB) / 2 + markExtend / 2) 0
|
|
local f : Widen {'d'} 0.95 1
|
|
include f.d
|
|
include MarkSet.b
|
|
|
|
save 'dcaron' 0x10F
|
|
|
|
sketch # dcurlytail
|
|
local fine : adviceBlackness 4
|
|
local rinner : clamp (Width * 0.065) (XH * 0.05) (fine * 0.35)
|
|
local wide Stroke
|
|
local m1 : Math.min RightSB (Width - rinner * 2 - fine - OX)
|
|
local x2 : mix SB m1 0.5
|
|
local y2 : 0 - fine - rinner * 1.25
|
|
include MarkSet.e
|
|
include : OBarRightShape XH m1
|
|
include : dispiro
|
|
widths.rhs
|
|
flat m1 CAP [heading Downward]
|
|
curl m1 (rinner * 2 + fine)
|
|
CurlyTail fine rinner m1 0 (m1 + rinner * 2 + fine) x2 y2
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (m1 - Stroke * HVContrast) CAP SideJut
|
|
|
|
save 'dcurlytail' 0x221
|
|
|
|
sketch # dhooktop
|
|
include MarkSet.b
|
|
include : OBarRightShape
|
|
include : VBarRight RightSB 0 XH
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) XH HookX (-Hook)
|
|
if SLAB : include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
|
|
save 'dhooktop' 0x257
|
|
|
|
sketch # ddot
|
|
include : refer-glyph "dotAbove"
|
|
apply-transform : Translate (Width - HalfStroke) 0
|
|
include [refer-glyph 'd'] AS_BASE
|
|
save 'ddot' 0x1E0B
|
|
|
|
sketch # latinde
|
|
include [refer-glyph 'd'] AS_BASE
|
|
include : HBarTop [mix RightSB SB 0.9] (RightSB + O) CAP
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif [mix RightSB SB 0.9] CAP VJut
|
|
save 'latinde' 0x18C
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-P : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export PShape PShapeOutline RevPShape PBarPosY
|
|
|
|
define [PBarPosY top sw bp] : (top - sw) * bp - sw * PShape.SwBelowBar
|
|
define [PShapeOutlineKnots top mul bp overshoot sw offset] : begin
|
|
local bowlTop (top * 1 - offset)
|
|
local bowlBottom : [PBarPosY top sw bp] + offset
|
|
local turnRadius : (bowlTop - bowlBottom) * 0.45
|
|
local sma : SmoothAOf (Smooth * 0.9) Width
|
|
local smb : SmoothBOf (Smooth * 0.9) Width
|
|
local right : RightSB - offset
|
|
|
|
if (bowlTop - bowlBottom <= sma + smb) : begin
|
|
local turn : mix bowlTop bowlBottom (smb / (sma + smb))
|
|
return : list
|
|
flat (SB * mul - O) bowlTop [heading Rightward]
|
|
curl (right - turnRadius - CorrectionOMidS) bowlTop
|
|
archv
|
|
straight.down.mid (right - overshoot) turn
|
|
arcvh
|
|
flat (right - turnRadius + CorrectionOMidS) bowlBottom
|
|
curl (SB * mul - O) bowlBottom [heading Leftward]
|
|
: else : begin
|
|
return : list
|
|
flat (SB * mul - O) bowlTop [heading Rightward]
|
|
curl (right - turnRadius - CorrectionOMidS) bowlTop
|
|
archv
|
|
flat (right - overshoot) (bowlTop - smb)
|
|
curl (right - overshoot) (bowlBottom + sma)
|
|
arcvh
|
|
flat (right - turnRadius + CorrectionOMidS) bowlBottom
|
|
curl (SB * mul - O) bowlBottom [heading Leftward]
|
|
|
|
define [RevPshapeOutlineKnots top mul bp overshoot sw offset] : begin
|
|
local bowlTop (top * 1 - offset)
|
|
local bowlBottom ((top - sw) * bp - sw * PShape.SwBelowBar + offset)
|
|
local turnRadius : (bowlTop - bowlBottom) * 0.45
|
|
local sma : SmoothAOf (Smooth * 0.9) Width
|
|
local smb : SmoothBOf (Smooth * 0.9) Width
|
|
local left : SB + offset
|
|
|
|
if (bowlTop - bowlBottom <= sma + smb) : begin
|
|
local turn : mix bowlTop bowlBottom (sma / (sma + smb))
|
|
return : list
|
|
flat (Width - SB * mul + O) bowlTop [heading Leftward]
|
|
curl (left + turnRadius - CorrectionOMidS) bowlTop
|
|
archv
|
|
straight.down.mid (left + overshoot) turn
|
|
arcvh
|
|
flat (left + turnRadius + CorrectionOMidS) bowlBottom
|
|
curl (Width - SB * mul + O) bowlBottom [heading Rightward]
|
|
: else : begin
|
|
return : list
|
|
flat (Width - SB * mul + O) bowlTop [heading Leftward]
|
|
curl (left + turnRadius - CorrectionOMidS) bowlTop
|
|
archv
|
|
flat (left + overshoot) (bowlTop - sma)
|
|
curl (left + overshoot) (bowlBottom + smb)
|
|
arcvh
|
|
flat (left + turnRadius + CorrectionOMidS) bowlBottom
|
|
curl (Width - SB * mul + O) bowlBottom [heading Rightward]
|
|
|
|
define [PShapeOutline] : params [top [mul PShape.defaultMul] [bp PShape.BarPos] [overshoot PShape.defaultOvershoot] [sw Stroke] [offset 0]] : glyph-construction
|
|
include : spiro-outline
|
|
PShapeOutlineKnots top mul bp overshoot sw offset
|
|
|
|
define [PShape] : params [top [mul PShape.defaultMul] [bp PShape.BarPos] [overshoot PShape.defaultOvershoot] [sw Stroke] [slab SLAB] [withBar true]] : glyph-construction
|
|
include : dispiro
|
|
widths.rhs sw
|
|
PShapeOutlineKnots top mul bp overshoot sw 0
|
|
if withBar : begin
|
|
include : tagged 'strokeL' : VBarLeft (SB * mul) 0 top sw
|
|
if slab : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif (SB * mul) top SideJut sw
|
|
include : CenterBottomSerif (SB * mul + HalfStroke * HVContrast) 0 Jut sw
|
|
|
|
define [RevPShape] : params [top [mul PShape.defaultMul] [bp PShape.BarPos] [overshoot PShape.defaultOvershoot] [sw Stroke] [slab SLAB]] : glyph-construction
|
|
include : tagged 'bowl' : dispiro
|
|
widths.lhs sw
|
|
RevPshapeOutlineKnots top mul bp overshoot sw 0
|
|
include : tagged 'strokeR' : VBarRight (Width - SB * mul) 0 top sw
|
|
|
|
if slab : begin
|
|
include : tagged 'serifRT'
|
|
RightwardTopSerif (Width - SB * mul) top SideJut sw
|
|
include : tagged 'serifRB'
|
|
CenterBottomSerif (Width - SB * mul - HalfStroke * HVContrast) 0 Jut sw
|
|
|
|
set PShape.defaultMul 1.25
|
|
set PShape.defaultOvershoot (OX * 2)
|
|
set PShape.BarPos (1 - HBarPos)
|
|
set PShape.SwBelowBar 0.25
|
|
|
|
sketch # P
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : PShape CAP
|
|
if SLAB : include : RightwardBottomSerif (SB * PShape.defaultMul + HalfStroke * HVContrast) 0 MidJutSide
|
|
save 'P' 'P'
|
|
save 'Rho' 0x3A1
|
|
save 'cyrEr' 0x420
|
|
|
|
sketch # Phookleft
|
|
include [refer-glyph 'P'] AS_BASE
|
|
eject-contour "serifLT"
|
|
include : LeftHook (SB * 1.25) CAP
|
|
|
|
save 'Phookleft' 0x1A4
|
|
|
|
create-glyph 'symbol/currency/pesetaSign' 0x20A7 : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : PShape CAP (mul -- 2) (overshoot -- 0)
|
|
if SLAB : include : RightwardBottomSerif (SB * 2 + HalfStroke * HVContrast) 0 MidJutSide
|
|
include : Translate (-SB * 0.5) 0
|
|
define sw : adviceBlackness2 2 4 CAP
|
|
include : HBar [mix 0 SB 0.5] [mix Width RightSB 0.5] [mix CAP [PBarPosY CAP Stroke PShape.BarPos] 0.5] sw
|
|
|
|
create-glyph 'symbol/currency/rubleSign' 0x20BD : glyph-construction
|
|
include [refer-glyph 'P'] AS_BASE ALSO_METRICS
|
|
define bar1pos : [PBarPosY CAP Stroke PShape.BarPos] + HalfStroke
|
|
include : HOverlayBar [mix SB 0 0.7] (SB + HalfStroke * HVContrast) bar1pos
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.8] [mix 0 (bar1pos - Stroke) (3 / 4)]
|
|
|
|
glyph-block Letter-Latin-Lower-P : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # p
|
|
set-width Width
|
|
include MarkSet.p
|
|
|
|
include : tagged 'bowl' : OBarLeftShape
|
|
include : VBarLeft SB Descender XH
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
include : tagged 'serifLB' : union
|
|
LeftwardBottomSerif (SB + HalfStroke * HVContrast) Descender Jut
|
|
RightwardBottomSerif (SB + HalfStroke * HVContrast) Descender MidJutSide
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'p' 'p'
|
|
save 'cyrer' 0x440
|
|
|
|
sketch # phooktop
|
|
include MarkSet.if
|
|
include : OBarLeftShape
|
|
include : HooktopLeftBar nothing Descender
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) Descender Jut
|
|
|
|
save 'phooktop' 0x1A5
|
|
### rho
|
|
sketch # rho
|
|
include MarkSet.p
|
|
include : OShape XH 0 (SB - OX + O) RightSB
|
|
include : VBar (SB + HalfStroke * HVContrast + O) Descender SmallSmoothB
|
|
save 'rho' 0x3C1
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-R : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-Upper-P : PShape RevPShape PBarPosY
|
|
|
|
### R and CyrYa
|
|
glyph-block-export RLegShape RLegTerminalX
|
|
define [RLegTerminalX straight right sw] : right - [if straight (OX * 2) 0] - sw / 2 * HVContrast
|
|
define [RLegShape] : params [top bottom left right charTop slab straight sw extraShift] : glyph-construction
|
|
local xRightBottom : RLegTerminalX straight right sw
|
|
if straight : do
|
|
local shift : if slab (-Jut / 2 + 0.25 * sw * HVContrast) 0
|
|
include : dispiro
|
|
widths.center (sw * [diagCor (top - bottom) (right - left - extraShift) 0 sw])
|
|
corner (left + extraShift + shift / 2) top [heading Downward]
|
|
corner (xRightBottom + shift) bottom [heading Downward]
|
|
if slab : begin
|
|
include : RightwardBottomSerif (xRightBottom + shift + 0.25 * sw * HVContrast) bottom (SideJut + Jut / 8)
|
|
: else : begin
|
|
include : intersection
|
|
Rect top bottom (-Width) (2 * Width)
|
|
dispiro
|
|
widths.center sw
|
|
g4.up.start xRightBottom bottom [heading Upward]
|
|
quadcontrols 0 0.4 8
|
|
g4 left top
|
|
if slab : begin
|
|
include : RightwardBottomSerif right bottom (SideJut + Jut / 8)
|
|
|
|
define [RevRLegTerminalX straight left sw] : left + [if straight (OX * 2) 0] + sw / 2 * HVContrast
|
|
define [RevRLegShape] : params [top bottom left right charTop slab straight sw extraShift] : glyph-construction
|
|
local xLeftBottom : RevRLegTerminalX straight left sw
|
|
if straight : do
|
|
local shift : if slab (-Jut / 2 + 0.25 * sw * HVContrast) 0
|
|
include : dispiro
|
|
widths.center (sw * [diagCor (top - bottom) (right - left - extraShift) 0 sw])
|
|
corner (right + extraShift + shift / 2) top [heading Downward]
|
|
corner (xLeftBottom + shift) bottom [heading Downward]
|
|
if slab : begin
|
|
include : LeftwardBottomSerif (xLeftBottom + shift - 0.25 * sw * HVContrast) bottom (SideJut + Jut / 8)
|
|
: else : begin
|
|
include : intersection
|
|
Rect top 0 (-Width) (2 * Width)
|
|
dispiro
|
|
widths.center sw
|
|
g4.up.start xLeftBottom bottom [heading Upward]
|
|
quadcontrols 0 0.4 8
|
|
g4 right top
|
|
if slab : begin
|
|
include : LeftwardBottomSerif left bottom (SideJut + Jut / 8)
|
|
|
|
define [RBarPos charTop slab] : if slab (0.5 + Stroke * PShape.SwBelowBar / charTop) PShape.BarPos
|
|
define [RBarTop charTop stroke straightBar slab] : (charTop - Stroke) * [RBarPos charTop slab] + [if straightBar 0 (Stroke / 2)]
|
|
define [RShape] : params [straightBar top [mul 1] [slab SLAB]] : glyph-construction
|
|
include : PShape top (mul -- mul) (bp -- [RBarPos top slab]) (overshoot -- O) (slab -- slab)
|
|
local right (RightSB - O - [if SLAB (Jut / 8) 0])
|
|
include : RLegShape [RBarTop top Stroke straightBar slab] 0 Middle right top slab straightBar Stroke 0
|
|
define [RevRShape] : params [straightBar top [mul 1] [slab SLAB]] : glyph-construction
|
|
include : RevPShape top (mul -- mul) (bp -- [RBarPos top slab]) (overshoot -- O) (slab -- slab)
|
|
local left (SB + O + [if SLAB (Jut / 8) 0])
|
|
include : RevRLegShape [RBarTop top Stroke straightBar slab] 0 left Middle top slab straightBar Stroke 0
|
|
|
|
sketch # R
|
|
include MarkSet.capital
|
|
branch
|
|
include : RShape true CAP
|
|
set-base-anchor 'overlay'
|
|
SB + Stroke * HVContrast
|
|
PBarPosY CAP Stroke : RBarPos CAP SLAB
|
|
save 'R.straight'
|
|
branch
|
|
include : RShape true CAP (slab -- false)
|
|
set-base-anchor 'overlay'
|
|
SB + Stroke * HVContrast
|
|
PBarPosY CAP Stroke : RBarPos CAP 0
|
|
eject-contour 'strokeL'
|
|
save 'Rrotunda.straight'
|
|
branch
|
|
include : RShape false CAP
|
|
set-base-anchor 'overlay'
|
|
SB + Stroke * HVContrast
|
|
PBarPosY CAP Stroke : RBarPos CAP SLAB
|
|
save 'R.curly'
|
|
branch
|
|
include : RShape false CAP (slab -- false)
|
|
set-base-anchor 'overlay'
|
|
SB + Stroke * HVContrast
|
|
PBarPosY CAP Stroke : RBarPos CAP 0
|
|
eject-contour 'strokeL'
|
|
save 'Rrotunda.curly'
|
|
|
|
define [IndianRupeeShape suffix straightBar] : glyph-construction
|
|
define bp : RBarPos CAP 0
|
|
include : intersection
|
|
Rect CAP 0 SB Width
|
|
WithTransform [Translate (-Width / 8) 0]
|
|
PShape CAP (bp -- bp) (slab -- false) (withBar -- false)
|
|
local right : RightSB - O - [if straightBar 0 (Width / 16)]
|
|
include : RLegShape [RBarTop CAP Stroke straightBar false] 0 (Width * 0.375) right CAP false straightBar Stroke 0
|
|
|
|
define sw : adviceBlackness2 2 4 CAP
|
|
include : HBarTop SB RightSB CAP sw
|
|
include : HBar SB RightSB [mix CAP [PBarPosY CAP Stroke bp] 0.5] sw
|
|
|
|
create-glyph 'symbol/currency/indianRupeeSign.straight' : IndianRupeeShape 'straight' true
|
|
create-glyph 'symbol/currency/indianRupeeSign.curly' : IndianRupeeShape 'curly' false
|
|
|
|
sketch # smcpR
|
|
include MarkSet.e
|
|
branch
|
|
include : RShape true XH
|
|
save 'smcpR.straight'
|
|
branch
|
|
include : RShape true XH (slab -- false)
|
|
eject-contour 'strokeL'
|
|
save 'rrotunda.straight'
|
|
branch
|
|
include : RShape false XH
|
|
save 'smcpR.curly'
|
|
branch
|
|
include : RShape false XH (slab -- false)
|
|
eject-contour 'strokeL'
|
|
save 'rrotunda.curly'
|
|
|
|
select-variant 'R' 'R'
|
|
select-variant 'Rrotunda' 0xA75A (follow -- 'R')
|
|
select-variant 'symbol/currency/indianRupeeSign' 0x20B9 (follow -- 'R')
|
|
select-variant 'smcpR' 0x280 (follow -- 'R')
|
|
select-variant 'rrotunda' 0xA75B (follow -- 'R')
|
|
|
|
WithDerivatives 'R' 'Rbar' : lambda [src sel] : glyph-construction
|
|
if [not sel] : assign-unicode 0x24C
|
|
include [refer-glyph src] AS_BASE ALSO_METRICS
|
|
include : HBar [mix 0 SB 0.3] (SB - O) ((CAP - Stroke) * [RBarPos CAP SLAB] + Stroke * 0.25)
|
|
|
|
WithDerivatives 'smcpR' 'turnSmcpR' : lambda [src sel] : glyph-construction
|
|
if [not sel] : assign-unicode 0x1D1A
|
|
include [refer-glyph src] AS_BASE ALSO_METRICS
|
|
include : FlipAround Middle (XH / 2)
|
|
|
|
sketch # Yr
|
|
include MarkSet.if
|
|
local top : CAP * 0.85
|
|
local bp 0.45
|
|
include : PShape top (mul -- 1) (bp -- bp)
|
|
include : VBarLeft SB (top - 1) CAP
|
|
|
|
local right (RightSB - O - [if SLAB (Jut / 8) 0])
|
|
branch
|
|
include : RLegShape ((top - Stroke) * bp) Descender Middle right (top - Descender) SLAB true Stroke 0
|
|
save 'Yr.straight'
|
|
branch
|
|
include : RLegShape ((top - Stroke) * bp) Descender Middle right (top - Descender) SLAB false Stroke 0
|
|
save 'Yr.curly'
|
|
|
|
select-variant 'Yr' 0x1A6 (follow -- 'R')
|
|
|
|
sketch # cyrYa
|
|
include MarkSet.capital
|
|
branch
|
|
include : RevRShape true CAP
|
|
save 'cyrYa.straight'
|
|
branch
|
|
include : RevRShape false CAP
|
|
save 'cyrYa.curly'
|
|
sketch # cyrya
|
|
include MarkSet.e
|
|
branch
|
|
include : RevRShape true XH
|
|
save 'cyrya.straight'
|
|
branch
|
|
include : RevRShape false XH
|
|
save 'cyrya.curly'
|
|
|
|
select-variant 'cyrYa' 0x42F (follow -- 'R')
|
|
select-variant 'cyrya' 0x44F (follow -- 'R')
|
|
|
|
turned 'invsmcpR.straight' nothing 'cyrya.straight' Middle (XH / 2)
|
|
turned 'invsmcpR.curly' nothing 'cyrya.curly' Middle (XH / 2)
|
|
select-variant 'invsmcpR' 0x281 (follow -- 'R')
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-R : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
local dfR : DivFrame para.diversityF
|
|
local rStraight 0
|
|
local rSerifed 1
|
|
local rNarrow 2
|
|
|
|
define [RDim mode] : begin
|
|
local rBalanceMultiplier : match mode [0 1] [1 (4 / 3)] [2 (1 / 2)]
|
|
local rHookMultiplier : match mode [0 1] [1 (2 / 3)] [2 1]
|
|
local rHookSwMultiplier : match mode [0 0] [1 (1 / 4)] [2 0]
|
|
local rSerifLeftExtender : match mode [0 0] [1 (1 / 3)] [2 0]
|
|
local hookSuperness : match mode [0 2.35] [1 2.75] [2 2.35]
|
|
|
|
local rbar : SB + RBalance * rBalanceMultiplier + Stroke * HVContrast
|
|
local rSerifX : rbar - HalfStroke * HVContrast
|
|
local rSerifLeftJut : SideJut + RBalance * (0.3 + rSerifLeftExtender)
|
|
local rSerifRightJut : rSerifLeftJut * 1.20
|
|
local [rBottomSerif y] : tagged 'serifLB' : union
|
|
LeftwardBottomSerif rSerifX y (rSerifLeftJut + HalfStroke * HVContrast)
|
|
RightwardBottomSerif rSerifX y (rSerifRightJut + HalfStroke * HVContrast)
|
|
local [rTopSerif y] : tagged 'serifLT'
|
|
LeftwardTopSerif rSerifX y (rSerifLeftJut + HalfStroke * HVContrast)
|
|
local fine : ShoulderFine * CThin
|
|
local rHookX (dfR.rightSB + RBalance2 * rBalanceMultiplier - (OX - O))
|
|
local rmiddle : match mode
|
|
0 : mix (rbar - fine) rHookX (0.54 + 2 * TanSlope * Stroke / Width)
|
|
1 : mix (rbar - fine) rHookX (0.59 + 2 * TanSlope * Stroke / Width)
|
|
2 : mix rHookX dfR.width (3 / 8)
|
|
local mixpin : match mode
|
|
0 : 0.65 + 4 * TanSlope * Stroke / Width
|
|
1 : 0.65 + 0.25 * Stroke / Width + 4 * TanSlope * Stroke / Width
|
|
2 : 0.65 + 4 * TanSlope * Stroke / Width
|
|
local rmiddlein : [mix rbar (rHookX - Stroke * HVContrast * 1.05) mixpin] - CorrectionOMidS
|
|
local skew : Math.max 0 : (rmiddle - rmiddlein) / Stroke
|
|
local rHookY : RHook * rHookMultiplier + Stroke * rHookSwMultiplier
|
|
return : object rbar rBottomSerif rTopSerif fine rmiddle skew rHookX rHookY hookSuperness
|
|
|
|
define [StandardLowerRShape df md doTopSerif doBottomSerif] : glyph-construction
|
|
define [object rbar rBottomSerif rTopSerif fine rmiddle skew rHookX rHookY hookSuperness] : RDim md
|
|
include : dispiro
|
|
widths.lhs
|
|
g4.up.start rHookX (XH - rHookY - Stroke * 0.5) [heading Upward]
|
|
arcvh nothing hookSuperness
|
|
g4.left.mid (rmiddle - CorrectionOMidS * [linreg 72 0.75 108 1 Stroke]) (XH - O) [widths.heading Stroke 0 {.y (-1) .x (-skew)}]
|
|
archv
|
|
straight.down.end (rbar - fine * HVContrast) (XH * 0.53 + (SmallSmooth - SmallSmoothA)) [widths.heading fine 0 Downward]
|
|
include : VBarRight rbar 0 XH
|
|
set-base-anchor 'overlay' (rbar - Stroke * 0.25) (XH * 0.5)
|
|
if doBottomSerif : include : rBottomSerif 0
|
|
if doTopSerif : include : rTopSerif XH
|
|
|
|
define [NarrowLowerRshape df md doTopSerif doBottomSerif] : glyph-construction
|
|
define [object rbar fine rmiddle] : RDim rNarrow
|
|
include : dispiro
|
|
widths.lhs
|
|
g4.left.mid (rmiddle - CorrectionOMidS * [linreg 72 0.75 108 1 Stroke]) (XH - O)
|
|
archv
|
|
straight.down.end (rbar - fine * HVContrast) (XH * 0.53 + (SmallSmooth - SmallSmoothA)) [widths.heading fine 0 Downward]
|
|
include : VBarRight rbar 0 XH
|
|
set-base-anchor 'overlay' (rbar - Stroke * 0.25) (XH * 0.5)
|
|
|
|
sketch
|
|
set-width dfR.width
|
|
include dfR.markSet.e
|
|
branch
|
|
include : StandardLowerRShape dfR rStraight 0 0
|
|
save "r.straight"
|
|
branch
|
|
include : StandardLowerRShape dfR rSerifed 1 1
|
|
save "r.serifed"
|
|
branch
|
|
include : StandardLowerRShape dfR rSerifed 1 0
|
|
save "r.top-serifed"
|
|
|
|
sketch # r.narrow
|
|
set-width dfR.width
|
|
include dfR.markSet.e
|
|
include : NarrowLowerRshape dfR rNarrow 0 0
|
|
save 'r.narrow'
|
|
|
|
select-variant 'r' 'r'
|
|
|
|
do
|
|
define [marks] : compositeBaseAnchors dfR.markSet.e {.baseAnchors {.bottomright {.x (dfR.rightSB - RBalance) .y 0}}}
|
|
turned 'turnr.straight' nothing 'r.straight' dfR.middle (XH / 2) [marks]
|
|
turned 'turnr.serifed' nothing 'r.serifed' dfR.middle (XH / 2) [marks]
|
|
turned 'turnr.top-serifed' nothing 'r.top-serifed' dfR.middle (XH / 2) [marks]
|
|
turned 'turnr.narrow' nothing 'r.narrow' dfR.middle (XH / 2) [marks]
|
|
select-variant 'turnr' 0x279 (follow -- 'r')
|
|
|
|
do
|
|
define [SmallRLongLegShape F mode doTopSerif] : glyph-construction
|
|
define [object rbar rBottomSerif] : RDim mode
|
|
include : F dfR mode doTopSerif 0
|
|
eject-contour 'serifLB'
|
|
include : VBarRight rbar Descender 0
|
|
if SLAB : include : rBottomSerif Descender
|
|
|
|
sketch # rlongleg.standard
|
|
set-width dfR.width
|
|
include dfR.markSet.p
|
|
branch
|
|
include : SmallRLongLegShape StandardLowerRShape rStraight 0
|
|
save 'rlongleg.straight'
|
|
branch
|
|
include : SmallRLongLegShape StandardLowerRShape rSerifed 1
|
|
save 'rlongleg.serifed'
|
|
branch
|
|
include : SmallRLongLegShape StandardLowerRShape rSerifed 1
|
|
save 'rlongleg.top-serifed'
|
|
branch
|
|
include : SmallRLongLegShape NarrowLowerRshape rNarrow 0
|
|
save 'rlongleg.narrow'
|
|
|
|
select-variant 'rlongleg' 0x27C (follow -- 'r')
|
|
|
|
do
|
|
local [marks] : compositeBaseAnchors dfR.markSet.b {.baseAnchors {.bottomright {.x (dfR.rightSB - RBalance) .y 0}}}
|
|
turned 'turnrlongleg.straight' nothing 'rlongleg.straight' dfR.middle (XH / 2) [marks]
|
|
turned 'turnrlongleg.serifed' nothing 'rlongleg.serifed' dfR.middle (XH / 2) [marks]
|
|
turned 'turnrlongleg.top-serifed' nothing 'rlongleg.top-serifed' dfR.middle (XH / 2) [marks]
|
|
turned 'turnrlongleg.narrow' nothing 'rlongleg.narrow' dfR.middle (XH / 2) [marks]
|
|
select-variant 'turnrlongleg' 0x27A (follow -- 'r')
|
|
|
|
do
|
|
define [SmallRRTailShape F mode doTopSerif] : glyph-construction
|
|
define [object rbar] : RDim mode
|
|
include : F dfR mode doTopSerif 0
|
|
eject-contour 'serifLB'
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate rbar 0
|
|
apply-transform : Italify
|
|
sketch # rrtail
|
|
set-width dfR.width
|
|
include dfR.markSet.p
|
|
branch
|
|
include : SmallRRTailShape StandardLowerRShape rStraight 0
|
|
save 'rrtail.straight'
|
|
branch
|
|
include : SmallRRTailShape StandardLowerRShape rSerifed 1
|
|
save 'rrtail.serifed'
|
|
branch
|
|
include : SmallRRTailShape StandardLowerRShape rSerifed 1
|
|
save 'rrtail.top-serifed'
|
|
branch
|
|
include : SmallRRTailShape NarrowLowerRshape rNarrow 0
|
|
save 'rrtail.narrow'
|
|
select-variant 'rrtail' 0x27D (follow -- 'r')
|
|
|
|
do
|
|
turned 'smallLetterTurnedRWithTail.straight' nothing 'rrtail.straight' dfR.middle (XH / 2)
|
|
turned 'smallLetterTurnedRWithTail.serifed' nothing 'rrtail.serifed' dfR.middle (XH / 2)
|
|
turned 'smallLetterTurnedRWithTail.top-serifed' nothing 'rrtail.top-serifed' dfR.middle (XH / 2)
|
|
turned 'smallLetterTurnedRWithTail.narrow' nothing 'rrtail.narrow' dfR.middle (XH / 2)
|
|
select-variant 'smallLetterTurnedRWithTail' 0x2C79 (follow -- 'r')
|
|
|
|
do
|
|
define [TurnRRTailShape F mode doBottomSerif] : glyph-construction
|
|
define [object rbar] : RDim mode
|
|
include : F dfR mode 0 doBottomSerif
|
|
eject-contour 'serifLT'
|
|
include : FlipAround dfR.middle (XH / 2)
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate (dfR.rightSB - rbar + dfR.leftSB + Stroke * HVContrast) 0
|
|
apply-transform : Italify
|
|
sketch # turnrrtail
|
|
set-width dfR.width
|
|
include dfR.markSet.p
|
|
branch
|
|
include : TurnRRTailShape StandardLowerRShape rStraight 0
|
|
save 'turnrrtail.straight'
|
|
branch
|
|
include : TurnRRTailShape StandardLowerRShape rSerifed 1
|
|
save 'turnrrtail.serifed'
|
|
branch
|
|
include : TurnRRTailShape StandardLowerRShape rSerifed 0
|
|
save 'turnrrtail.top-serifed'
|
|
branch
|
|
include : TurnRRTailShape NarrowLowerRshape rNarrow 0
|
|
save 'turnrrtail.narrow'
|
|
|
|
select-variant 'turnrrtail' 0x27B (follow -- 'r')
|
|
|
|
sketch # rflap
|
|
set-width dfR.width
|
|
include dfR.markSet.e
|
|
define [object rbar rBottomSerif rHookY] : RDim rStraight
|
|
local rHookX (RightSB + RBalance2 - (OX - O))
|
|
local rmiddle : [mix rbar (rHookX - HalfStroke) 0.5] - CorrectionOMidS
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 rHookX (XH - rHookY)
|
|
hookstart (XH - O)
|
|
flat (rbar - Stroke * HVContrast) (XH - SmallSmoothA)
|
|
curl (rbar - Stroke * HVContrast) 0 [heading Downward]
|
|
|
|
branch
|
|
save 'rflap.straight'
|
|
save 'rflap.top-serifed'
|
|
branch
|
|
include : rBottomSerif 0
|
|
save 'rflap.serifed'
|
|
|
|
sketch # rflap.narrow
|
|
set-width dfR.width
|
|
include dfR.markSet.e
|
|
define [object rbar rBottomSerif rmiddle] : RDim rNarrow
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
g4.left.start (rmiddle - CorrectionOMidS * [linreg 72 0.75 108 1 Stroke]) (XH - O)
|
|
archv
|
|
flat (rbar - Stroke * HVContrast) (XH - SmallSmoothA)
|
|
curl (rbar - Stroke * HVContrast) 0 [heading Downward]
|
|
if SLAB : include : rBottomSerif 0
|
|
save 'rflap.narrow'
|
|
|
|
select-variant 'rflap' 0x27E (follow -- 'r')
|
|
|
|
|
|
glyph-block Letter-Latin-C : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export CShape CShapeOutline
|
|
|
|
define [CShape top bot sw] : glyph-construction
|
|
include : dispiro
|
|
widths.lhs sw
|
|
g4 RightSB (top - Hook)
|
|
hookstart (top - O)
|
|
flat (SB + OX) (top - SmoothA)
|
|
curl (SB + OX) (bot + SmoothB)
|
|
hookend (bot + O)
|
|
g4 RightSB (bot + Hook)
|
|
|
|
define [CShapeOutline top bot _offset] : glyph-construction
|
|
define offset : fallback _offset 1
|
|
include : spiro-outline
|
|
g4 RightSB (top - Hook)
|
|
hookstart (top - O - offset)
|
|
flat (SB + OX + offset) (top - SmoothA)
|
|
curl (SB + OX + offset) (bot + SmoothB)
|
|
hookend (bot + O + offset)
|
|
g4 RightSB (bot + Hook)
|
|
|
|
sketch # C
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : CShape CAP 0
|
|
save 'C' 'C'
|
|
save 'cyrEs' 0x421
|
|
save 'lunateSigma' 0x3F9
|
|
|
|
create-glyph 'symbol/currency/euroSign' 0x20AC : glyph-construction
|
|
include [refer-glyph "C"] AS_BASE ALSO_METRICS
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.7] (CAP * 0.4)
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.7] (CAP * 0.6)
|
|
|
|
sketch # c
|
|
set-width Width
|
|
include MarkSet.e
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 RightSB (XH - Hook)
|
|
hookstart (XH - O)
|
|
flat (SB + OX) (XH - SmallSmoothA)
|
|
curl (SB + OX) (0 + SmallSmoothB)
|
|
hookend O
|
|
g4 RightSB Hook
|
|
save 'c' 'c'
|
|
save 'cyres' 0x441
|
|
save 'lunatesigma' 0x3F2
|
|
|
|
create-glyph 'symbol/currency/centSign' 0xA2 : glyph-construction
|
|
define fine : adviceBlackness 4
|
|
include [refer-glyph 'c'] AS_BASE ALSO_METRICS
|
|
include : dispiro
|
|
widths.center
|
|
flat Middle (XH - HalfStroke)
|
|
curl Middle (XH - Descender / 2) [heading Upward]
|
|
include : dispiro
|
|
widths.center
|
|
flat Middle (Descender / 2) [heading Upward]
|
|
curl Middle HalfStroke
|
|
include : VBar Middle (XH - HalfStroke) (0 + HalfStroke) fine
|
|
|
|
turned 'turnC' 0x186 'C' Middle (CAP / 2)
|
|
turned 'turnc' 0x254 'c' Middle (XH / 2)
|
|
composite [refer-glyph 'turnc'] [into-unicode 0x037B]
|
|
composite [refer-glyph 'turnC'] [into-unicode 0x03FD]
|
|
composite [refer-glyph 'c'] [DotAt (Middle + HalfStroke / 4) (XH/2) DotRadius] [into-unicode 0x037C]
|
|
composite [refer-glyph 'turnc'] [DotAt (Middle - HalfStroke / 4) (XH/2) DotRadius] [into-unicode 0x037D]
|
|
composite [refer-glyph 'C'] [DotAt (Middle + HalfStroke / 4) (CAP/2) DotRadius] [into-unicode 0x03FE]
|
|
composite [refer-glyph 'turnC'] [DotAt (Middle - HalfStroke / 4) (CAP/2) DotRadius] [into-unicode 0x03FF]
|
|
|
|
sketch # strenchedC
|
|
set-width Width
|
|
include MarkSet.p
|
|
include : CShape XH Descender
|
|
|
|
save 'strenchedC' 0x297
|
|
|
|
sketch # Chooktop
|
|
include [refer-glyph 'C'] AS_BASE
|
|
include : VBarRight (RightSB - OXHook) (CAP - Hook) CAP
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast - OXHook) CAP HookX (-Hook)
|
|
|
|
save 'Chooktop' 0x187
|
|
|
|
sketch # chooktop
|
|
include [refer-glyph 'c'] AS_BASE
|
|
include : VBarRight (RightSB - OXHook) (XH - Hook) XH
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast - OXHook) XH HookX (-Hook)
|
|
|
|
save 'chooktop' 0x188
|
|
|
|
sketch # Cbar
|
|
include [refer-glyph 'C'] AS_BASE
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + Stroke) (RightSB - Stroke) 0.55] (CAP * OverlayPos)
|
|
|
|
save 'Cbar' 0xA792
|
|
|
|
sketch # cbar
|
|
include [refer-glyph 'c'] AS_BASE
|
|
include : HOverlayBar (SB * 0.3) [mix (SB + Stroke) (RightSB - Stroke) 0.55] (XH * OverlayPos)
|
|
|
|
save 'cbar' 0xA793
|
|
|
|
sketch # ccurlytail
|
|
include MarkSet.e
|
|
local stroke : adviceBlackness2 2.875 2 XH
|
|
local fine : adviceBlackness2 3 3 XH
|
|
local rinner : ((XH * 0.45) - fine * 1.5) / 2
|
|
local m1 : SB + O + stroke * HVContrast
|
|
local x2 : SB + stroke * 0.3
|
|
local y2 : -XH * 0.05
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
g4 RightSB (XH - Hook)
|
|
hookstart XH
|
|
flat (SB + OX) (XH - SmallSmoothA)
|
|
curl (SB + OX) SmallSmoothB
|
|
arcvh
|
|
CurlyTail fine rinner m1 0 RightSB x2 y2
|
|
|
|
save 'ccurlytail' 0x255
|
|
|
|
sketch # cyrE
|
|
include [refer-glyph "C"] AS_BASE
|
|
include : FlipAround Middle (CAP / 2)
|
|
include : HBar [mix SB RightSB 0.25] RightSB (CAP / 2)
|
|
save 'cyrE' 0x42D
|
|
|
|
sketch # cyre
|
|
include [refer-glyph "c"] AS_BASE
|
|
include : FlipAround Middle (XH / 2)
|
|
include : HBar [mix SB RightSB 0.25] RightSB (XH / 2)
|
|
save 'cyre' 0x44D
|
|
|
|
sketch # cyrYe
|
|
include [refer-glyph "C"] AS_BASE
|
|
include : HBar SB [mix RightSB SB 0.25] (CAP / 2) [adviceBlackness2 4 2 CAP]
|
|
save 'cyrYe' 0x404
|
|
|
|
sketch # cyrye
|
|
include [refer-glyph "c"] AS_BASE
|
|
include : HBar SB [mix RightSB SB 0.25] (XH / 2) [adviceBlackness2 4 2 XH]
|
|
save 'cyrye' 0x454
|
|
|
|
sketch # sigma
|
|
include MarkSet.e
|
|
include : spiro-outline
|
|
corner (RightSB + 0.25 * SB) XH
|
|
corner (RightSB + 0.25 * SB) (XH - Stroke)
|
|
corner Middle (XH - Stroke - O * 1.5)
|
|
corner Middle (XH - O)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat (Middle + 1) (XH - O)
|
|
curl Middle (XH - O)
|
|
archv
|
|
flat (SB + OX) (XH - SmallSmoothA)
|
|
curl (SB + OX) SmallSmoothB
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) O
|
|
archv
|
|
flat (RightSB - OX * 0.5) SmallSmoothA
|
|
curl (RightSB - OX * 0.5) (XH - SmallSmoothB)
|
|
arcvh
|
|
flat Middle (XH - HalfStroke - O) [widths HalfStroke 0]
|
|
curl (Middle - 1) (XH - HalfStroke - O)
|
|
save 'sigma' 0x3C3
|
|
|
|
sketch # sigmafinal
|
|
include MarkSet.p
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 RightSB (XH - Hook)
|
|
hookstart XH
|
|
flat (SB + OX) (XH - SmallSmoothA)
|
|
curl (SB + OX) SmallSmoothB
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) 0
|
|
alsoThru 0.5 0.1353
|
|
g4.down.mid (RightSB - Stroke * HVContrast + OX) [mix Descender Stroke : StrokeWidthBlend 0.5 0.49] [heading Downward]
|
|
arcvh
|
|
flat (RightSB - HookX + OX) (Descender + Stroke) [heading Leftward]
|
|
curl [Math.min (RightSB - Stroke * HVContrast * 1.5) (RightSB - HookX + OX - 1)] (Descender + Stroke) [heading Leftward]
|
|
save 'sigmafinal' 0x3C2
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-G : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [GShape fTooth top sma smb] : glyph-construction
|
|
local yBar : top * 0.52 + Stroke * 0.25
|
|
local fine ShoulderFine
|
|
local sb : shoulderMidSlope fine nothing (-1)
|
|
|
|
local knots : list
|
|
widths.lhs
|
|
g4 RightSB (top - Hook)
|
|
hookstart (top - O)
|
|
flat (SB + OX) (top - sma)
|
|
curl (SB + OX) smb
|
|
arcvh
|
|
|
|
if fTooth
|
|
: then : knots.push
|
|
g4.right.mid (Middle + (CorrectionOMidX - sb) * Stroke) O [widths.heading Stroke 0 {.y (1) .x (sb)}]
|
|
archv
|
|
straight.up.end (RightSB - (Stroke - fine) * HVContrast) sma [widths.heading fine 0 Upward]
|
|
: else : knots.push
|
|
g4 (Middle + CorrectionOMidS) O
|
|
flat RightSB sma
|
|
curl RightSB yBar [heading Upward]
|
|
|
|
include : union
|
|
dispiro.apply null knots
|
|
HBarTop Middle RightSB yBar
|
|
if fTooth
|
|
then : union
|
|
VBarRight RightSB (sma + O) yBar
|
|
VBarRight RightSB sma 0 [Math.max [adviceBlackness 5] (Stroke - fine / 2)]
|
|
else : glyph-construction
|
|
|
|
define [HookTopShapeOfG top] : union
|
|
VBarRight (RightSB - OXHook) (top - Hook) top
|
|
VerticalHook (RightSB - HalfStroke * HVContrast - OXHook) top HookX (-Hook) nothing O
|
|
|
|
define [OverlayBarOfG top] : HOverlayBar [mix SB RightSB 0.5] [mix RightSB Width 0.7] [mix 0 (top / 2) 0.55]
|
|
|
|
sketch # G
|
|
include MarkSet.capital
|
|
branch
|
|
include : GShape true CAP SmoothA SmoothB
|
|
save 'G.toothed'
|
|
branch
|
|
include : HookTopShapeOfG CAP
|
|
save 'Ghooktop.toothed'
|
|
branch
|
|
include : OverlayBarOfG CAP
|
|
save 'Gbar.toothed'
|
|
|
|
branch
|
|
include : GShape false CAP SmoothA SmoothB
|
|
save 'G.toothless'
|
|
branch
|
|
include : HookTopShapeOfG CAP
|
|
save 'Ghooktop.toothless'
|
|
branch
|
|
include : OverlayBarOfG CAP
|
|
save 'Gbar.toothless'
|
|
|
|
|
|
sketch # smcpG
|
|
include MarkSet.e
|
|
branch
|
|
include : GShape true XH SmoothA SmoothB
|
|
save 'smcpG.toothed'
|
|
branch
|
|
include : HookTopShapeOfG XH
|
|
save 'smcpGhooktop.toothed'
|
|
|
|
branch
|
|
include : GShape false XH SmoothA SmoothB
|
|
save 'smcpG.toothless'
|
|
branch
|
|
include : HookTopShapeOfG XH
|
|
save 'smcpGhooktop.toothless'
|
|
|
|
select-variant 'G' 'G'
|
|
select-variant 'smcpG' 0x262 (follow -- 'G')
|
|
select-variant 'Ghooktop' 0x193 (follow -- 'G')
|
|
select-variant 'smcpGhooktop' 0x29B (follow -- 'G')
|
|
select-variant 'Gbar' 0x1E4 (follow -- 'G')
|
|
turned 'turnG' 0x2141 'G' Middle (CAP / 2)
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-G : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # g.doublestorey
|
|
include MarkSet.p
|
|
local obot : XH * designParameters.gBarPos - O - Stroke * 0.4
|
|
include : OShape XH obot SB (RightSB - 0.3 * SB)
|
|
|
|
local gleftx ([mix 0 SB 0.85] + OX)
|
|
local grightx ([mix Width RightSB 0.825] - OX)
|
|
local groundy : Math.round : [mix Descender (XH * designParameters.gBarPos) 0.64] + HalfStroke
|
|
local gtipy : [mix groundy (obot + Stroke + O) 1.005] - Stroke * CThin
|
|
include : dispiro
|
|
g4.left.start [mix SB RightSB 0.4] gtipy [widths 0 (Stroke * CThin)]
|
|
g4 ([mix SB RightSB 0.0575] + Stroke * 0.85) [mix groundy gtipy 0.5] [widths.rhs (Stroke * [mix CThin 1 0.5])]
|
|
flat [mix SB RightSB 0.435] groundy [widths 0 Stroke]
|
|
curl [mix RightSB SB 0.435] groundy
|
|
archv 4
|
|
g4 grightx [mix (Descender + O) groundy (1.06 * SmallSmoothA / (SmallSmoothA + SmallSmoothB))]
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) (Descender + O)
|
|
archv
|
|
g4 gleftx [mix (Descender + O) groundy (1.06 * SmallSmoothB / (SmallSmoothA + SmallSmoothB))]
|
|
arcvh
|
|
g4 [mix SB RightSB 0.435] groundy [heading Rightward]
|
|
local gm : mix SB (RightSB - 0.3 * SB) 0.5
|
|
include : spiro-outline
|
|
corner (RightSB + 0.25 * SB - OX) XH
|
|
corner (RightSB + 0.25 * SB - OX) (XH - Stroke)
|
|
corner gm (XH - Stroke - O)
|
|
corner gm XH
|
|
|
|
set-base-anchor 'overlay' Middle [mix (Descender + O) groundy 0.5]
|
|
save 'g.doublestorey'
|
|
|
|
sketch # g.opendoublestorey
|
|
include MarkSet.p
|
|
local obot : XH * designParameters.gBarPos - O - Stroke * 0.4
|
|
include : OShape XH obot SB (RightSB - 0.3 * SB)
|
|
|
|
local gleftx ([mix 0 SB 0.85] + OX)
|
|
local grightx ([mix Width RightSB 0.825] - OX)
|
|
local groundy : Math.round : [mix Descender (XH * designParameters.gBarPos) 0.64] + HalfStroke
|
|
local gtipy : [mix groundy (obot + Stroke + O) 1.005] - Stroke * CThin
|
|
include : dispiro
|
|
g4.left.start [mix SB RightSB 0.4] gtipy [widths 0 (Stroke * CThin)]
|
|
g4 ([mix SB RightSB 0.0575] + Stroke * 0.85) [mix groundy gtipy 0.5] [widths.rhs (Stroke * [mix CThin 1 0.5])]
|
|
flat [mix SB RightSB 0.435] groundy [widths 0 Stroke]
|
|
curl [mix RightSB SB 0.435] groundy
|
|
archv 4
|
|
g4 grightx [mix (Descender + O) groundy (1.06 * SmallSmoothA / (SmallSmoothA + SmallSmoothB))]
|
|
hookend (Descender + O)
|
|
g4 gleftx [mix (Descender + O) groundy (1.06 * SmallSmoothB / (SmallSmoothA + SmallSmoothB))]
|
|
local gm : mix SB (RightSB - 0.3 * SB) 0.5
|
|
include : spiro-outline
|
|
corner (RightSB + 0.25 * SB - OX) XH
|
|
corner (RightSB + 0.25 * SB - OX) (XH - Stroke)
|
|
corner gm (XH - Stroke - O)
|
|
corner gm XH
|
|
|
|
set-base-anchor 'overlay' Middle [mix (Descender + O) groundy 0.5]
|
|
save 'g.opendoublestorey'
|
|
|
|
sketch # g.singlestorey
|
|
include MarkSet.p
|
|
include : OBarRightShape
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RightSB XH [heading Downward]
|
|
curl RightSB (Descender + SmallSmoothA)
|
|
hookend (Descender + O)
|
|
g4 SB (Descender + SHook)
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif RightSB XH SideJut
|
|
set-base-anchor 'overlay' Middle (XH / 2)
|
|
save 'g.singlestorey'
|
|
save 'scriptg' 0x261
|
|
save 'cyrde.SRB'
|
|
|
|
select-variant 'g' 'g'
|
|
turned nothing 0x1D77 'g' Middle [mix Descender XH 0.5]
|
|
|
|
sketch # scriptghooktop
|
|
include [refer-glyph 'scriptg'] AS_BASE
|
|
eject-contour 'serifRT'
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) XH HookX (-Hook) nothing O
|
|
|
|
save 'scriptghooktop' 0x260
|
|
|
|
do
|
|
define l : mix 0 SB 0.3
|
|
define r : mix Width RightSB 0.3
|
|
define bwDoubleStorey : Math.min [adviceBlackness 5] (0.5 / 3 * (CAP - Stroke * 4))
|
|
define bwSingleStorey : adviceBlackness2 4 2 XH
|
|
sketch # gbar.doublestorey
|
|
include [refer-glyph "g.doublestorey"] AS_BASE
|
|
include : HBar l r [query-glyph "g.doublestorey"].baseAnchors.overlay.y bwDoubleStorey
|
|
save 'gbar.doublestorey'
|
|
sketch # gbar.opendoublestorey
|
|
include [refer-glyph "g.opendoublestorey"] AS_BASE
|
|
include : HBar l r [query-glyph "g.opendoublestorey"].baseAnchors.overlay.y bwDoubleStorey
|
|
save 'gbar.opendoublestorey'
|
|
sketch # gbar.singlestorey
|
|
include [refer-glyph "g.singlestorey"] AS_BASE
|
|
include : HBar l r [query-glyph "g.singlestorey"].baseAnchors.overlay.y bwSingleStorey
|
|
save 'gbar.singlestorey'
|
|
select-variant "gbar" 0x1E5 (follow -- 'g')
|
|
|
|
|
|
glyph-block Letter-Latin-O : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch
|
|
include MarkSet.capital
|
|
include : OShape CAP 0 SB RightSB nothing SmoothA SmoothB
|
|
set-base-anchor 'trailing' Middle 0
|
|
save 'O' 'O'
|
|
save 'Omicron' 0x39F
|
|
save 'cyrO' 0x41E
|
|
|
|
sketch # o
|
|
set-width Width
|
|
include MarkSet.e
|
|
include : OShape XH 0 SB RightSB nothing nothing nothing
|
|
set-base-anchor 'trailing' Middle 0
|
|
save 'o' 'o'
|
|
save 'omicron' 0x3BF
|
|
save 'cyro' 0x43e
|
|
|
|
sketch
|
|
include MarkSet.capital
|
|
include : HornBaseAnchor RightSB CAP (Width / 2) (SmoothB) 0.5
|
|
include : difference
|
|
create-glyph : glyph-construction
|
|
include MarkSet.capital
|
|
include [refer-glyph 'longHorn']
|
|
OShapeOutline.NoOvershoot CAP 0 SB RightSB nothing SmoothA SmoothB
|
|
include : refer-glyph "O"
|
|
save 'OHorn' 0x01A0
|
|
|
|
sketch
|
|
include MarkSet.e
|
|
include : HornBaseAnchor RightSB XH (Width / 2) (SmoothB) 0.5
|
|
include : difference
|
|
create-glyph : glyph-construction
|
|
include MarkSet.e
|
|
include [refer-glyph 'longHorn']
|
|
OShapeOutline.NoOvershoot XH 0 SB RightSB nothing nothing nothing
|
|
include : refer-glyph "o"
|
|
save 'oHorn' 0x01A1
|
|
|
|
sketch # Oslash
|
|
local fine : 0.5 * OverlayStroke
|
|
include [refer-glyph 'O'] AS_BASE
|
|
include : dispiro
|
|
flat (SB + O + fine) [mix CAP 0 1.05] [widths fine fine]
|
|
curl (RightSB - O - fine) [mix 0 CAP 1.05]
|
|
save 'Oslash' 0xD8
|
|
|
|
sketch # oslash
|
|
local fine : 0.5 * OverlayStroke
|
|
include [refer-glyph 'o'] AS_BASE
|
|
include : dispiro
|
|
flat (SB + O + fine) [mix XH 0 1.05] [widths fine fine]
|
|
curl (RightSB - O - fine) [mix 0 XH 1.05]
|
|
save 'oslash' 0xF8
|
|
|
|
sketch # Obar
|
|
include [refer-glyph 'O'] AS_BASE
|
|
include : HBar (SB + OX + 1) (RightSB - OX - 1) (CAP * 0.5) OverlayStroke
|
|
save 'Obar' 0x19F
|
|
save 'cyrOe' 0x4E8
|
|
save 'capSymbolTheta' 0x3F4
|
|
|
|
sketch # obar
|
|
include [refer-glyph 'o'] AS_BASE
|
|
include : HBar (SB + OX + 1) (RightSB - OX - 1) (XH * 0.5) OverlayStroke
|
|
save 'obar' 0x275
|
|
save 'cyroe' 0x4E9
|
|
|
|
sketch # bulleye
|
|
include [refer-glyph 'O'] AS_BASE
|
|
local halfDotWidth : Math.min DotRadius ((RightSB - SB - HVContrast * Stroke * 2) / 4)
|
|
local halfDotHeight : Math.min DotRadius (halfDotWidth * 1.5)
|
|
include : OShapeOutline.NoOvershoot
|
|
CAP / 2 + halfDotHeight
|
|
CAP / 2 - halfDotHeight
|
|
Middle + halfDotWidth
|
|
Middle - halfDotWidth
|
|
Stroke * halfDotWidth * 2 / Width
|
|
SmoothAOf halfDotWidth (halfDotWidth * 2)
|
|
SmoothBOf halfDotWidth (halfDotWidth * 2)
|
|
|
|
save 'bulleye' 0x298
|
|
|
|
sketch # oupperhalf
|
|
include MarkSet.e
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (SB + OX) (XH / 2) [heading Upward]
|
|
curl (SB + OX) (XH - [Math.min (XH / 2 - 0.1) SmallSmoothA])
|
|
arcvh
|
|
g4 (Middle - CorrectionOMidS) (XH - O)
|
|
archv
|
|
flat (RightSB - OX) (XH - [Math.min (XH / 2 - 0.1) SmallSmoothB])
|
|
curl (RightSB - OX) (XH / 2) [heading Downward]
|
|
save 'oupperhalf' 0x1D16
|
|
|
|
sketch # olowerhalf
|
|
include MarkSet.e
|
|
include : dispiro
|
|
widths.lhs
|
|
flat (SB + OX) (XH / 2) [heading Downward]
|
|
curl (SB + OX) [Math.min (XH / 2 - 0.1) SmallSmoothB]
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) O
|
|
archv
|
|
flat (RightSB - OX) [Math.min (XH / 2 - 0.1) SmallSmoothA]
|
|
curl (RightSB - OX) (XH / 2) [heading Upward]
|
|
save 'olowerhalf' 0x1D17
|
|
|
|
create-glyph 'oWithLightCentralizationStroke' : glyph-construction
|
|
include MarkSet.p
|
|
include : refer-glyph "o"
|
|
local fine : adviceBlackness 4
|
|
local outStand : SB * 0.75 + fine * 0.25
|
|
local outStandY : SmallSmoothB / 2 - Descender * 0.6
|
|
local yTurn : SmallSmoothB / 2
|
|
include : difference
|
|
dispiro
|
|
widths.lhs fine
|
|
corner Middle (yTurn + outStandY)
|
|
corner (SB - outStand) (yTurn - outStandY)
|
|
OShapeOutline.NoOvershoot XH 0 SB RightSB nothing nothing nothing
|
|
|
|
glyph-block Letter-Latin-Upper-Q : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # Q.straight
|
|
set-width Width
|
|
include [refer-glyph 'O'] AS_BASE
|
|
local shift : StrokeWidthBlend 0 0.25
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (Middle + Width * 0.075 - Stroke * HVContrast * shift) (-CAP * 0.2) [heading Upward]
|
|
curl (Middle - Stroke * HVContrast * shift) 0
|
|
save 'Q.straight'
|
|
sketch # Q.taily
|
|
set-width Width
|
|
include [refer-glyph 'O'] AS_BASE
|
|
local shift : StrokeWidthBlend 0.5 0.6
|
|
local startx : Middle + (Stroke * shift) * HVContrast
|
|
local terminalx : Middle + HookX
|
|
include : dispiro
|
|
widths.rhs
|
|
flat startx HalfStroke [heading Downward]
|
|
curl startx 0 [heading Downward]
|
|
arcvh
|
|
flat [Math.min (terminalx - 1) (startx + Hook - Stroke)] (Stroke - Hook)
|
|
curl terminalx (Stroke - Hook)
|
|
save 'Q.taily'
|
|
|
|
select-variant 'Q' 'Q'
|
|
alias 'cyrQa' 0x51A 'Q'
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-Q : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-Lower-I : TailedIShape
|
|
|
|
create-glyph 'q.straight' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.p
|
|
|
|
include : OBarRightShape
|
|
include : VBarRight RightSB Descender XH
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif RightSB XH SideJut
|
|
include : LeftwardBottomSerif (RightSB - HalfStroke * HVContrast) Descender MidJutSide
|
|
include : RightwardBottomSerif (RightSB - HalfStroke * HVContrast) Descender Jut
|
|
|
|
create-glyph 'q.tailed' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.p
|
|
|
|
include : OBarRightShape
|
|
include : dispiro
|
|
widths.rhs
|
|
flat RightSB XH
|
|
curl RightSB (Descender + Hook * 0.5 + Stroke + O * 2)
|
|
g4 (RightSB + Hook * 0.25) (Descender + Stroke * 0.75 + O * 2)
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif RightSB XH SideJut
|
|
|
|
select-variant 'q' 'q'
|
|
alias 'cyrqa' 0x51B 'q'
|
|
|
|
sketch # Qrtail
|
|
include MarkSet.capital
|
|
include : OBarRightShape CAP
|
|
include : VBarRight RightSB 0 CAP
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate RightSB 0
|
|
apply-transform : Italify
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif RightSB CAP SideJut
|
|
|
|
save 'Qrtail' 0x24A
|
|
|
|
sketch # qrtail
|
|
include MarkSet.e
|
|
include : OBarRightShape
|
|
include : VBarRight RightSB 0 XH
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate RightSB 0
|
|
apply-transform : Italify
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : RightwardTopSerif RightSB XH SideJut
|
|
|
|
save 'qrtail' 0x24B
|
|
|
|
sketch # qhooktop
|
|
include [refer-glyph "q.straight"] AS_BASE
|
|
eject-contour 'serifRT'
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) XH HookX (-Hook)
|
|
save 'qhooktop' 0x2A0
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-N : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export NShape
|
|
|
|
define [NShape top left right crowd diagcrowd xn] : glyph-construction
|
|
local topstroke : adviceBlackness [fallback diagcrowd 4]
|
|
local stroke : adviceBlackness [fallback crowd 1]
|
|
local halftopstroke : topstroke / 2
|
|
|
|
include : union
|
|
AINSerifs top left right stroke xn
|
|
dispiro
|
|
flat left 0 [widths.heading 0 stroke Upward]
|
|
curl left (top * 0.4) [heading Upward]
|
|
straight.up.end left top [widths.heading 0 topstroke Upward]
|
|
dispiro
|
|
flat right top [widths.heading 0 stroke Downward]
|
|
curl right (top * 0.6) [heading Downward]
|
|
straight.down.end right 0 [widths.heading 0 topstroke Downward]
|
|
dispiro
|
|
flat (left + halftopstroke) top [widths.heading topstroke 0 Downward]
|
|
curl (right - halftopstroke) 0 [widths.heading 0 topstroke Downward]
|
|
|
|
sketch # N
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : NShape CAP SB RightSB
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
save 'N' 'N'
|
|
save 'Nu' 0x39D
|
|
|
|
sketch # smcpN
|
|
include MarkSet.e
|
|
include : NShape XH SB RightSB 3 3.5
|
|
save 'smcpN' 0x274
|
|
|
|
create-glyph 'symbol/currency/nairaSign' 0x20A6 : glyph-construction
|
|
include : NShape CAP (SB * 1.25) (Width - SB * 1.25) 3.5 4
|
|
define sw : adviceBlackness2 2 4 CAP
|
|
define gap : Math.max (CAP / 6) sw
|
|
include : HBarBottom [mix 0 SB 0.5] [mix Width RightSB 0.5] (CAP / 2 + gap / 2) sw
|
|
include : HBarTop [mix 0 SB 0.5] [mix Width RightSB 0.5] (CAP / 2 - gap / 2) sw
|
|
|
|
sketch # Nltail
|
|
include [refer-glyph 'N'] AS_BASE
|
|
eject-contour 'serifLB'
|
|
include : VerticalHook (SB + HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
save 'Nltail' 0x19D
|
|
|
|
glyph-block Letter-Latin-Lower-N : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # n
|
|
set-width Width
|
|
include MarkSet.e
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
fine -- ShoulderFine
|
|
include : VBarLeft SB 0 XH
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
if (para.isItalic)
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (RightSB - HalfStroke * HVContrast) 0 Jut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
save 'n' 'n'
|
|
save 'cyrpe.italic'
|
|
|
|
sketch # napostrophe
|
|
include : refer-glyph "commaAbove"
|
|
apply-transform : Translate (Width + SB - Middle) 0
|
|
include [refer-glyph 'n'] AS_BASE
|
|
|
|
save 'napostrophe' 0x149
|
|
|
|
sketch # eng
|
|
include MarkSet.p
|
|
include [refer-glyph 'n'] false
|
|
eject-contour 'serifRB'
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
|
|
save 'eng' 0x14B
|
|
|
|
sketch # Eng
|
|
include MarkSet.capital
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke)
|
|
right -- RightSB
|
|
top -- CAP
|
|
bottom -- (Hook + HalfStroke + O)
|
|
sma -- SmoothA
|
|
smb -- SmoothB
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) (Hook + HalfStroke + O) [Math.max ((SB - RightSB) / 2 + HalfStroke) (-HookX)] Hook
|
|
include : VBar (SB + HalfStroke * HVContrast) 0 CAP
|
|
|
|
save 'Eng' 0x14A
|
|
|
|
sketch # nltail
|
|
include [refer-glyph 'n'] AS_BASE
|
|
eject-contour 'serifLB'
|
|
include : VerticalHook (SB + HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
|
|
save 'nltail' 0x272
|
|
|
|
sketch # ncurlytail
|
|
local fine : adviceBlackness 4
|
|
local rinner : clamp (Width * 0.065) (XH * 0.05) (fine * 0.35)
|
|
local wide : adviceBlackness 3
|
|
local m1 : Math.min RightSB (Width - rinner * 2 - fine - OX)
|
|
local x2 : mix SB m1 0.5
|
|
local y2 : -fine
|
|
include MarkSet.e
|
|
include : VBarLeft SB 0 XH wide
|
|
include : dispiro
|
|
nShoulderKnots
|
|
left -- (SB + wide * HVContrast)
|
|
right -- m1
|
|
fine -- ShoulderFine
|
|
bottom -- (rinner * 2 + fine)
|
|
stroke -- wide
|
|
CurlyTail fine rinner m1 0 (m1 + rinner * 2 + fine) x2 y2
|
|
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
|
|
save 'ncurlytail' 0x235
|
|
# eta
|
|
sketch # eta
|
|
include MarkSet.p
|
|
set-base-anchor 'lf' (SB + HalfStroke) 0
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
bottom -- Descender
|
|
include : VBarLeft SB 0 XH
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
|
|
save 'eta' 0x3B7
|
|
|
|
sketch # latinEta
|
|
include MarkSet.if
|
|
set-base-anchor 'lf' (SB + HalfStroke) 0
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
top -- CAP
|
|
bottom -- Descender
|
|
include : VBar (SB + HalfStroke * HVContrast) 0 CAP
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB CAP SideJut
|
|
if (para.isItalic)
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif RightSB Descender SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (RightSB - HalfStroke * HVContrast) Descender Jut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
|
|
save 'latinEta' 0x220
|
|
|
|
sketch # latineta
|
|
include MarkSet.p
|
|
set-base-anchor 'lf' (SB + HalfStroke) 0
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
bottom -- Descender
|
|
include : VBarLeft SB 0 XH
|
|
if SLAB : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif SB XH SideJut
|
|
if (para.isItalic)
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif RightSB Descender SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (RightSB - HalfStroke * HVContrast) Descender Jut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
save 'latineta' 0x19E
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-U : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export UShape
|
|
|
|
define [UShape df top bottom stroke oper] : glyph-construction
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
flat df.leftSB top [heading Downward]
|
|
curl df.leftSB (bottom + SmoothB * [Math.sqrt df.div])
|
|
arcvh
|
|
g4 (df.middle + CorrectionOMidS) (bottom + O)
|
|
archv
|
|
flat df.rightSB (bottom + SmoothA * [Math.sqrt df.div])
|
|
curl df.rightSB top [heading Upward]
|
|
if [not oper] : include : AIVSerifs top
|
|
|
|
sketch # U
|
|
include MarkSet.capital
|
|
include : UShape [DivFrame 1] CAP 0
|
|
set-base-anchor 'trailing' Middle 0
|
|
save 'U' 'U'
|
|
|
|
sketch # smcpU
|
|
include MarkSet.e
|
|
include : UShape [DivFrame 1] XH 0
|
|
save 'smcpU' 0x1D1C
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-U : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # u
|
|
set-width Width
|
|
include MarkSet.e
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
include : refer-glyph "n"
|
|
eject-contour 'serifRB'
|
|
eject-contour 'serifLB'
|
|
currentGlyph.reTagContour 'serifLT' 'serifRB'
|
|
include : FlipAround Middle (XH / 2)
|
|
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (RightSB - Stroke * HVContrast) XH SideJut
|
|
include : LeftwardTopSerif SB XH SideJut
|
|
|
|
save 'u.withBar'
|
|
|
|
create-glyph 'upsilon' 0x3C5 : glyph-construction
|
|
include MarkSet.e
|
|
set-base-anchor 'trailing' Middle 0
|
|
include : dispiro
|
|
widths.lhs
|
|
flat (SB + OX - O) XH [heading Downward]
|
|
curl (SB + OX - O) SmallSmoothB
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) O
|
|
archv
|
|
flat (RightSB - OX + O) SmallSmoothA
|
|
curl (RightSB - OX + O) XH [heading Upward]
|
|
|
|
create-glyph 'u.withoutBar' : glyph-construction
|
|
include [refer-glyph 'upsilon'] AS_BASE ALSO_METRICS
|
|
include : AIVSerifs XH
|
|
|
|
select-variant 'u' 'u'
|
|
create-glyph 'urtailBR' 0x1D99 : glyph-construction
|
|
include [refer-glyph 'u.withBar'] AS_BASE ALSO_METRICS
|
|
include [refer-glyph 'rtailBR']
|
|
|
|
define [LatinUpsilon2Shape top sma smb] : glyph-construction
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB top [heading Downward]
|
|
curl SB smb
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) O
|
|
archv
|
|
flat RightSB sma
|
|
curl RightSB (top - Hook - HalfStroke) [heading Upward]
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) (top - Hook - HalfStroke) (-(RightSB - HalfStroke * HVContrast - Middle)) (-Hook)
|
|
|
|
sketch # latinUpsilon2
|
|
include MarkSet.e
|
|
include : LatinUpsilon2Shape CAP SmoothA SmoothB
|
|
|
|
save 'latinUpsilon2' 0x1B2
|
|
|
|
sketch # latinupsilon2
|
|
include MarkSet.e
|
|
include : LatinUpsilon2Shape XH SmallSmoothA SmallSmoothB
|
|
save 'latinupsilon2' 0x28B
|
|
|
|
create-glyph 'uWithLightCentralizationStroke' : glyph-construction
|
|
include MarkSet.p
|
|
include : refer-glyph "u.withBar"
|
|
local fine : adviceBlackness 4
|
|
local outStand : SB * 0.75 + fine * 0.25
|
|
local outStandY : SmallSmoothB / 2 - Descender * 0.6
|
|
local yTurn : SmallSmoothB / 2
|
|
include : difference
|
|
dispiro
|
|
widths.lhs fine
|
|
corner (SB + outStand) (yTurn + outStandY)
|
|
corner (SB - outStand) (yTurn - outStandY)
|
|
spiro-outline
|
|
corner (SB - O) XH
|
|
curl (SB - O) SmallSmoothB
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) (-O)
|
|
archv
|
|
flat (RightSB + O) SmallSmoothA
|
|
corner (RightSB + O) XH
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif SB XH SideJut
|
|
|
|
glyph-block Letter-Latin-Upper-M : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [MShape top _div] : glyph-construction
|
|
local div : fallback _div 1
|
|
local df : DivFrame div 3
|
|
local topstroke : adviceBlackness 5 div
|
|
local halftopstroke : topstroke / 2
|
|
local middleY : top * 0.3 / div
|
|
|
|
include : dispiro
|
|
flat df.leftSB 0 [widths.heading 0 Stroke Upward]
|
|
curl df.leftSB (top * 0.2) [heading Upward]
|
|
straight.up.end df.leftSB top [widths.heading 0 topstroke Upward]
|
|
include : dispiro
|
|
flat df.rightSB 0 [widths.heading Stroke 0 Upward]
|
|
curl df.rightSB (top * 0.2) [heading Upward]
|
|
straight.up.end df.rightSB top [widths.heading topstroke 0 Upward]
|
|
include : dispiro
|
|
flat (df.leftSB + halftopstroke) top [widths.heading topstroke 0 Downward]
|
|
curl df.middle middleY [widths.heading (topstroke / 2) (topstroke / 2) Downward]
|
|
include : dispiro
|
|
flat (df.rightSB - halftopstroke) top [widths.heading 0 topstroke Downward]
|
|
curl df.middle middleY [widths.heading (topstroke / 2) (topstroke / 2) Downward]
|
|
include : AIMSerifs top df.leftSB df.rightSB
|
|
|
|
sketch # M
|
|
local df : DivFrame para.diversityM
|
|
include df.markSet.capital
|
|
set-width df.width
|
|
include : MShape CAP df.div
|
|
save 'M' 'M'
|
|
save 'Mu' 0x39C
|
|
save 'cyrEm' 0x41C
|
|
|
|
sketch # cyrem
|
|
local df : DivFrame para.diversityM
|
|
include df.markSet.e
|
|
set-width df.width
|
|
include : MShape XH df.div
|
|
save 'cyrem' 0x43C
|
|
save 'smcpM' 0x1D0D
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-M : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [dfM] : DivFrame para.diversityM 3
|
|
define [SmallMShape top bot mbot df] : glyph-construction
|
|
local m1 : mix df.leftSB (df.middle + df.mvs / 2 * HVContrast) 0.5
|
|
local m2 : mix df.rightSB (df.middle - df.mvs / 2 * HVContrast) 0.5
|
|
include : mShoulderSpiro
|
|
left -- (df.leftSB + df.mvs * HVContrast)
|
|
right -- (df.middle + df.mvs / 2 * HVContrast)
|
|
top -- top
|
|
bottom -- mbot
|
|
width -- df.mvs
|
|
fine -- (df.mvs * ShoulderFine / Stroke)
|
|
diversity -- df.div
|
|
include : mShoulderSpiro
|
|
left -- (df.middle + df.mvs * 0.5 * HVContrast)
|
|
right -- df.rightSB
|
|
top -- top
|
|
bottom -- bot
|
|
width -- df.mvs
|
|
fine -- (df.mvs * ShoulderFine / Stroke)
|
|
diversity -- df.div
|
|
include : VBarLeft df.leftSB bot top df.mvs
|
|
if SLAB : begin
|
|
local jut : Jut * df.mvs / Stroke + O
|
|
if (df.width > jut * 7) : begin
|
|
include : tagged 'serifLT' : intersection
|
|
CenterTopSerif (df.leftSB + 0.5 * df.mvs * HVContrast) top jut df.mvs
|
|
spiro-outline
|
|
corner SB bot
|
|
corner SB top
|
|
corner 0 top
|
|
corner 0 bot
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (df.leftSB + 0.5 * df.mvs * HVContrast) bot jut df.mvs
|
|
include : tagged 'serifMB' : CenterBottomSerif df.middle bot jut df.mvs
|
|
include : tagged 'serifRB' : CenterBottomSerif (df.rightSB - 0.5 * df.mvs * HVContrast) bot jut df.mvs
|
|
: else : begin
|
|
include : tagged 'serifRB' : intersection
|
|
RightwardBottomSerif (df.rightSB + O) bot (jut / 2) df.mvs
|
|
spiro-outline
|
|
corner (df.rightSB + O) bot
|
|
corner (df.rightSB + O) top
|
|
corner df.width top
|
|
corner df.width bot
|
|
: else : begin
|
|
include : tagged 'serifLT' : LeftwardTopSerif df.leftSB top SideJut df.mvs
|
|
if (!para.isItalic) : include : LeftwardBottomSerif df.leftSB bot SideJut df.mvs
|
|
include : tagged 'serifRB' : RightwardBottomSerif df.rightSB bot SideJut df.mvs
|
|
|
|
sketch # m.normal
|
|
local df : dfM
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : SmallMShape XH 0 0 df
|
|
save 'm.normal'
|
|
save 'cyrte.italic'
|
|
sketch # m.shortleg
|
|
local df : dfM
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : SmallMShape XH 0 ((XH - df.mvs) * 0.45) df
|
|
eject-contour 'serifMB'
|
|
save 'm.shortleg'
|
|
select-variant 'm' 'm'
|
|
composite 'cyrtedescender.italic' [refer-glyph 'cyrte.italic'] [CyrDescender (Width * para.diversityM - SB)] MarkSet.e
|
|
|
|
sketch # mltail
|
|
local df : dfM
|
|
include df.markSet.p
|
|
include : refer-glyph "m"
|
|
eject-contour 'serifRB'
|
|
include : VerticalHook (df.rightSB - df.mvs / 2 * HVContrast) 0 (-HookX) Hook df.mvs
|
|
save 'mltail' 0x271
|
|
|
|
turned 'turnm' 0x26F 'm.normal' [dfM].middle (XH / 2)
|
|
|
|
sketch # capitalTurnm
|
|
local df : dfM
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
include : SmallMShape CAP 0 0 df
|
|
include : FlipAround df.middle (CAP / 2)
|
|
save 'capitalTurnm' 0x19C
|
|
|
|
sketch # turnmleg
|
|
local df : dfM
|
|
set-width df.width
|
|
include df.markSet.p
|
|
include : refer-glyph "m.normal"
|
|
eject-contour 'serifLT'
|
|
include : FlipAround df.middle (XH / 2)
|
|
include : VBarRight df.rightSB Descender 0 df.mvs
|
|
save 'turnmleg' 0x270
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-H : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [HShape top] : glyph-construction
|
|
include : VBarLeft SB 0 top
|
|
include : VBarRight RightSB 0 top
|
|
include : HBar (SB - O) (RightSB + O) (top * HBarPos)
|
|
include : AIHSerifs top
|
|
|
|
sketch # H
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : HShape CAP
|
|
save 'H' 'H'
|
|
save 'Eta' 0x397
|
|
save 'cyrEn' 0x41D
|
|
|
|
sketch # cyren
|
|
include MarkSet.e
|
|
include : HShape XH
|
|
save 'cyren' 0x43D
|
|
save 'smcpH' 0x29C
|
|
|
|
composite [refer-glyph 'cyrEn'] [CyrDescender RightSB] [into-unicode 0x4A2]
|
|
composite [refer-glyph 'cyren'] [CyrDescender RightSB] [into-unicode 0x4A3]
|
|
|
|
define [EnGheShape top] : glyph-construction
|
|
local right : if SLAB ([mix RightSB SB 0.35] + MVertStroke / 2 * HVContrast) [mix RightSB SB 0.2]
|
|
local barRight : mix Width RightSB [if SLAB 0.25 0.375]
|
|
|
|
include : VBarLeft SB 0 top
|
|
include : VBarRight right 0 top
|
|
include : HBar (SB - O) (right + O) (top * HBarPos)
|
|
include : HBarTop (right - Stroke * 0.1) barRight top
|
|
|
|
if SLAB : begin
|
|
include : AIHSerifs top SB right
|
|
include : DownwardRightSerif barRight top VJut (MVertStroke / HVContrast)
|
|
|
|
|
|
sketch # cyrEnGhe
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : EnGheShape CAP
|
|
save 'cyrEnGhe' 0x4A4
|
|
|
|
sketch # cyrenghe
|
|
include MarkSet.e
|
|
include : EnGheShape XH
|
|
save 'cyrenghe' 0x4A5
|
|
|
|
sketch # Hbar
|
|
include [refer-glyph 'H'] AS_BASE
|
|
include : HOverlayBar [mix SB 0 0.7] [mix RightSB Width 0.7] [mix CapMiddle CAP 0.45]
|
|
save 'Hbar' 0x126
|
|
|
|
sketch # HCedilla
|
|
include [refer-glyph 'cedillaBelow']
|
|
apply-transform : Translate (Width + SB - Middle + HalfStroke * HVContrast) 0
|
|
include [refer-glyph 'H']
|
|
include MarkSet.if
|
|
save 'HCedilla' 0x1E28
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-H : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # h
|
|
set-width Width
|
|
include MarkSet.b
|
|
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
include : VBarLeft SB 0 CAP
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif SB CAP SideJut
|
|
if (para.isItalic)
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (RightSB - HalfStroke * HVContrast) 0 Jut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
save 'h' 'h'
|
|
save 'cyrshha' 0x4BB
|
|
|
|
sketch # hCedilla
|
|
include [refer-glyph 'cedillaBelow']
|
|
apply-transform : Translate (Width + SB - Middle + HalfStroke * HVContrast) 0
|
|
include [refer-glyph 'h']
|
|
include MarkSet.if
|
|
save 'hCedilla' 0x1E29
|
|
|
|
sketch # hhooktop
|
|
include MarkSet.b
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
include : HooktopLeftBar
|
|
if SLAB : begin
|
|
if (para.isItalic)
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif RightSB 0 SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (RightSB - HalfStroke * HVContrast) 0 Jut
|
|
if (!para.isItalic) : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (SB + HalfStroke * HVContrast) 0 Jut
|
|
|
|
save 'hhooktop' 0x266
|
|
|
|
sketch # hhooktopltail
|
|
include MarkSet.p
|
|
include : refer-glyph "hhooktop"
|
|
eject-contour 'serifRB'
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
|
|
save 'hhooktopltail' 0x267
|
|
|
|
sketch # hltail
|
|
include MarkSet.p
|
|
include : refer-glyph "h"
|
|
eject-contour 'serifRB'
|
|
include : VerticalHook (RightSB - HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
|
|
save 'hltail' 0xA727
|
|
turned nothing 0x265 'h' Middle (XH / 2) MarkSet.p
|
|
|
|
sketch # hookturnh
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
bottom -- (Hook + HalfStroke + 1)
|
|
include : VBarLeft SB 0 CAP
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate RightSB (Hook + HalfStroke)
|
|
apply-transform : Italify
|
|
include : FlipAround Middle (XH / 2)
|
|
include MarkSet.p
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (RightSB - Stroke * HVContrast) XH SideJut
|
|
include : CenterBottomSerif (RightSB - HalfStroke * HVContrast) Descender Jut
|
|
|
|
save 'hookturnh' 0x2AE
|
|
|
|
sketch # hookturnhrtail
|
|
include : nShoulder
|
|
left -- (SB + Stroke * HVContrast)
|
|
right -- RightSB
|
|
bottom -- (Hook + HalfStroke + 1)
|
|
include : VBarLeft SB 0 (XH - 1)
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate RightSB (Hook + HalfStroke)
|
|
apply-transform : Italify
|
|
include : FlipAround Middle (XH / 2)
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate RightSB 0
|
|
apply-transform : Italify
|
|
include MarkSet.p
|
|
if SLAB : begin
|
|
include : LeftwardTopSerif (RightSB - Stroke * HVContrast) XH SideJut
|
|
|
|
save 'hookturnhrtail' 0x2AF
|
|
|
|
sketch # hbar
|
|
include [refer-glyph 'h'] AS_BASE
|
|
include : HOverlayBar [mix SB 0 0.7] [mix SB RightSB 0.5] [mix XH CAP 0.45]
|
|
save 'hbar' 0x127
|
|
save 'cyrtshe' 0x45B
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-F : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-export FShape RevFShape EFVJutLength
|
|
|
|
define [xMidBarShrink] : [Math.max HalfStroke ((RightSB - SB) * 0.15)] + [if SLAB (Stroke * 0.25) 0]
|
|
define [yMidBar top y] : top * [fallback y : designParameters.upperEBarPos SLAB]
|
|
define [EFVJutLength top pyBar stroke] : begin
|
|
local jutTop : Math.min VJut
|
|
top - [mix (top - stroke) ([yMidBar top pyBar] + stroke / 2) 0.5]
|
|
local jutBot : Math.min VJut
|
|
mix stroke ([yMidBar top pyBar] - stroke / 2) 0.5
|
|
return { jutTop jutBot }
|
|
|
|
define [FShape] : params [top pyBar noSerif] : glyph-construction
|
|
define stroke : adviceBlackness2 2.875 2 CAP
|
|
define xFBarLeft : SB * 1.5
|
|
include : VBarLeft (xFBarLeft) 0 top stroke
|
|
include : HBarTop (xFBarLeft - O) RightSB top stroke
|
|
include : HBar (xFBarLeft - O) (RightSB - [xMidBarShrink]) [yMidBar top pyBar] stroke
|
|
if (SLAB && !noSerif) : begin
|
|
include : LeftwardTopSerif xFBarLeft top SideJut
|
|
include : tagged 'serifBottom' : LeftwardBottomSerif xFBarLeft 0 SideJut
|
|
include : tagged 'serifBottom' : RightwardBottomSerif (xFBarLeft + HalfStroke * HVContrast) 0 MidJutSide
|
|
local { jutTop jutBot } : EFVJutLength top pyBar stroke
|
|
include : DownwardRightSerif RightSB top jutTop
|
|
|
|
define [RevFShape] : params [top pyBar noSerif] : glyph-construction
|
|
define stroke : adviceBlackness2 2.875 2 CAP
|
|
define xFBarRight : Width - SB * 1.5
|
|
include : VBarRight (xFBarRight) 0 top stroke
|
|
include : HBarTop SB (xFBarRight + O) top stroke
|
|
include : HBar (SB + [xMidBarShrink]) (xFBarRight + O) [yMidBar top pyBar] stroke
|
|
if (SLAB && !noSerif) : begin
|
|
include : RightwardTopSerif xFBarRight top SideJut
|
|
include : tagged 'serifBottom' : RightwardBottomSerif xFBarRight 0 SideJut
|
|
include : tagged 'serifBottom' : LeftwardBottomSerif (xFBarRight - HalfStroke * HVContrast) 0 MidJutSide
|
|
local { jutTop jutBot } : EFVJutLength top pyBar stroke
|
|
include : DownwardLeftSerif SB top jutTop
|
|
|
|
create-glyph 'F' 'F' : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : FShape CAP
|
|
|
|
create-glyph 'symbol/currency/frenchFrancSign' 0x20A3 : glyph-construction
|
|
include : refer-glyph "F"
|
|
include : HOverlayBar (SB * 0.5) (SB * 3 + Stroke * HVContrast) [mix 0 XH 0.4]
|
|
|
|
create-glyph 'Fltail' 0x191 : glyph-construction
|
|
include [refer-glyph 'F'] AS_BASE
|
|
eject-contour 'serifBottom'
|
|
include : VerticalHook (SB * 1.5 + HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
|
|
glyph-block Letter-Latin-Lower-F : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
glyph-block-export LongSShape
|
|
|
|
define fovershoot : fallback para.fovershoot (O * 6)
|
|
|
|
sketch # longs.straight
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.center
|
|
flat (Middle - FBalance) 0 [heading Upward]
|
|
curl (Middle - FBalance) (CAP - FHook)
|
|
arcvh
|
|
straight.right.end (Middle - FBalance + HookX) (CAP - HalfStroke - fovershoot)
|
|
set-base-anchor 'overlay' (Middle - FBalance + Stroke * 0.5 * HVContrast) (CAP * OverlayPos)
|
|
if SLAB : begin
|
|
include : tagged 'serifMB' : CenterBottomSerif (Middle - FBalance) 0 Jut
|
|
|
|
branch
|
|
save 'longs.straight'
|
|
|
|
|
|
sketch # longs.upright
|
|
include MarkSet.b
|
|
local m : Middle - JBalance - HalfStroke * HVContrast
|
|
local r : m + (Width * 0.5) + Stroke * HVContrast - OXHook
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 r (CAP - Hook)
|
|
hookstart (CAP - O)
|
|
flat m (CAP - SmoothA)
|
|
curl m 0 [heading Downward]
|
|
set-base-anchor 'overlay' (m + Stroke * 0.65 * HVContrast) (CAP * OverlayPos)
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (m + HalfStroke * HVContrast + RBalance * 0.35) 0 (Jut + RBalance * 0.65)
|
|
branch
|
|
save 'longs.upright'
|
|
branch
|
|
include : HOverlayBar
|
|
m + HalfStroke * HVContrast - LongJut * 0.75
|
|
m + HalfStroke * HVContrast + LongJut * 0.75
|
|
[mix (XH - Stroke) CAP 0.5] - HalfStroke
|
|
save 'longsbar.upright'
|
|
|
|
define [LongSShape top bottom hookx hooky fine] : glyph-construction
|
|
local w [fallback fine Stroke]
|
|
include : dispiro
|
|
widths.center w
|
|
straight.right.start (Middle - hookx) (bottom + w / 2 + fovershoot)
|
|
flat Middle (bottom + hooky)
|
|
curl Middle (top - hooky)
|
|
straight.right.end (Middle + hookx) (top - w / 2 - fovershoot)
|
|
|
|
sketch 'esh'
|
|
include MarkSet.if
|
|
include : LongSShape CAP (-Hook) HookX Hook
|
|
|
|
branch
|
|
save 'longs.italic'
|
|
save 'esh' 0x283
|
|
|
|
branch
|
|
include : HOverlayBar (Middle - LongJut * 0.75) (Middle + LongJut * 0.75) (XH * 0.25)
|
|
save 'eshbar' 0x284
|
|
|
|
branch
|
|
include : HOverlayBar
|
|
Middle - LongJut * 0.75
|
|
Middle + LongJut * 0.75
|
|
[mix (XH - Stroke) CAP 0.5] - HalfStroke
|
|
save 'longsbar.italic'
|
|
|
|
|
|
create-glyph 'longs' 0x17F : glyph-construction
|
|
if (para.isItalic)
|
|
then : include [refer-glyph 'longs.italic'] AS_BASE ALSO_METRICS
|
|
else : include [refer-glyph 'longs.upright'] AS_BASE ALSO_METRICS
|
|
|
|
create-glyph 'longsbar' 0x1E9D : glyph-construction
|
|
if (para.isItalic)
|
|
then : include [refer-glyph 'longsbar.italic'] AS_BASE ALSO_METRICS
|
|
else : include [refer-glyph 'longsbar.upright'] AS_BASE ALSO_METRICS
|
|
|
|
sketch # eshcurlytail
|
|
include MarkSet.if
|
|
local fine : adviceBlackness 3.5
|
|
local rinner : LongJut / 2 - fine / 2
|
|
local m1 : Middle - HalfStroke * HVContrast - FBalance
|
|
local x2 : mix RightSB m1 0.25
|
|
local y2 : Descender + O
|
|
include [refer-glyph 'longs.straight'] false
|
|
eject-contour 'serifMB'
|
|
include : dispiro
|
|
widths.lhs
|
|
flat m1 XH [heading Downward]
|
|
curl m1 (Descender + fine + rinner * 2)
|
|
CurlyTail
|
|
fine -- fine
|
|
rinner -- rinner
|
|
xleft -- m1
|
|
bottom -- Descender
|
|
right -- (m1 - LongJut)
|
|
x2 -- x2
|
|
y2 -- y2
|
|
save 'eshcurlytail' 0x286
|
|
|
|
sketch # ifishhook
|
|
include MarkSet.p
|
|
include : VBar Middle Descender (XH - Hook)
|
|
include : VerticalHook Middle (XH - Hook) (-LongJut + LBalance) (-Hook + HalfStroke)
|
|
apply-transform : Translate LBalance 0
|
|
if SLAB : begin
|
|
include : CenterBottomSerif Middle Descender Jut
|
|
|
|
save 'ifishhook' 0x27F
|
|
|
|
sketch # iviby
|
|
include MarkSet.p
|
|
include : VBar Middle 0 (XH - Hook - HalfStroke)
|
|
include : VerticalHook Middle (XH - Hook - HalfStroke) (-LongJut) (-Hook)
|
|
include : VerticalHook Middle 0 LongJut Hook
|
|
|
|
save 'iviby' 0x285
|
|
|
|
define fbar : XH * designParameters.fBarPos + Stroke * para.fbarStrokeAdj
|
|
sketch # f.straight
|
|
local fovershoot2 (O * 2)
|
|
include MarkSet.b
|
|
|
|
local barleft : [mix SB RightSB 0.35] - Stroke * 0.25 * HVContrast
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 (RightSB + RBalance2 - (OX - O)) (CAP - Hook * 0.75 - fovershoot2)
|
|
hookstart (CAP - O - fovershoot2) (tight -- true)
|
|
flat barleft (CAP - SmoothA * 0.8 - fovershoot2)
|
|
curl barleft 0 [heading Downward]
|
|
|
|
branch
|
|
include : dispiro
|
|
widths.rhs
|
|
flat ([mix SB RightSB 0] - HalfStroke * TanSlope) fbar
|
|
curl ([mix SB RightSB 0.95] - HalfStroke * TanSlope) fbar
|
|
|
|
branch
|
|
save 'f.straight'
|
|
save 'lenisf' 0xAB35
|
|
|
|
branch
|
|
include : VerticalHook (barleft + HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
save 'fltail' 0x192
|
|
|
|
branch
|
|
include : dispiro
|
|
widths.lhs
|
|
flat ([mix SB RightSB 0.02] + HalfStroke * TanSlope) 0
|
|
curl ([mix SB RightSB 0.875] + HalfStroke * TanSlope) 0
|
|
save 'f.serifed'
|
|
|
|
branch
|
|
include MarkSet.if
|
|
include : VBarLeft barleft 0 (Descender * 0.9)
|
|
save 'f.straightTailed'
|
|
|
|
branch
|
|
include : dispiro
|
|
widths.rhs
|
|
flat ([mix SB RightSB 0] - HalfStroke * TanSlope) fbar
|
|
curl (RightSB - HalfStroke * TanSlope) fbar
|
|
|
|
branch
|
|
save 'f.phoneticLeft'
|
|
|
|
|
|
define dfNarrowF : DivFrame para.diversityF
|
|
sketch # f.narrow
|
|
local df : DivFrame para.diversityF
|
|
set-width df.width
|
|
include df.markSet.b
|
|
local crossLeft : mix 0 SB (1 / 2)
|
|
local crossRight : mix df.width df.rightSB (1 / 2)
|
|
local barleft : [mix crossLeft crossRight 0.42] - Stroke * 0.375 * HVContrast
|
|
local tTurn : Math.max (Hook * 0.9) (Stroke * 1.375) : Math.min Hook (Stroke * 1.75)
|
|
include : dispiro
|
|
widths.lhs
|
|
flat crossRight CAP
|
|
curl [Math.min (barleft + tTurn) (crossRight - 1)] CAP
|
|
archv
|
|
flat barleft [Math.max XH (CAP - tTurn)]
|
|
curl barleft 0 [heading Downward]
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (crossLeft - HalfStroke * TanSlope) fbar
|
|
curl (crossRight - HalfStroke * TanSlope) fbar
|
|
save 'f.narrow'
|
|
|
|
sketch # tailed
|
|
include [refer-glyph 'longs.italic'] AS_BASE
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (Middle - LongJut - HalfStroke * TanSlope) fbar
|
|
curl (Middle + LongJut - HalfStroke * TanSlope) fbar
|
|
save 'f.tailed'
|
|
|
|
select-variant 'f' 'f'
|
|
|
|
turned 'turnf.straight' nothing 'f.straight' Middle (XH / 2) MarkSet.p
|
|
turned 'turnf.serifed' nothing 'f.serifed' Middle (XH / 2) MarkSet.p
|
|
turned 'turnf.straightTailed' nothing 'f.straightTailed' Middle (XH / 2) MarkSet.p
|
|
turned 'turnf.narrow' nothing 'f.narrow' dfNarrowF.middle (XH / 2) dfNarrowF.markSet.p
|
|
turned 'turnf.tailed' nothing 'f.tailed' Middle (XH / 2) MarkSet.p
|
|
select-variant 'turnf' 0x25F (follow -- 'f')
|
|
|
|
do "f ligatures"
|
|
local shift (-(Width * 0.055 + SB * 0.5))
|
|
local barr RightSB
|
|
local hbarleft (SB + shift + Stroke * [if para.slantAngle 0.5 0.25])
|
|
|
|
sketch # f_i
|
|
include MarkSet.b
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "longs"
|
|
apply-transform : Translate shift 0
|
|
include : VBarRight barr 0 fbar
|
|
include : HBarTop hbarleft barr fbar
|
|
if SLAB : begin
|
|
if para.isItalic
|
|
: then : include : tagged 'serifRB' : RightwardBottomSerif barr 0 SideJut
|
|
: else : include : tagged 'serifRB' : CenterBottomSerif (barr - HalfStroke * HVContrast) 0 Jut
|
|
save 'f_i' 0xFB01
|
|
|
|
sketch # f_l.upright
|
|
local m : Middle - JBalance - HalfStroke * HVContrast + shift
|
|
include : dispiro
|
|
widths.rhs
|
|
flat m 0 [heading Upward]
|
|
curl m (CAP - SmoothA)
|
|
hookend (CAP - O)
|
|
g4 (barr + OXHook) (CAP - Hook)
|
|
include : VBarRight barr 0 (CAP - Hook)
|
|
include : dispiro
|
|
widths.rhs
|
|
flat ([Math.min (m - Stroke * 0.3) hbarleft] - TanSlope * HalfStroke) fbar
|
|
curl ([mix SB barr 0.6] - TanSlope * HalfStroke) fbar
|
|
if SLAB : begin
|
|
include : tagged 'serifLB' : CenterBottomSerif (m + HalfStroke * HVContrast + RBalance * 0.35) 0 (Jut + RBalance * 0.65)
|
|
include : tagged 'serifRB' : CenterBottomSerif (barr - HalfStroke * HVContrast) 0 Jut
|
|
save 'f_l.upright'
|
|
|
|
sketch # f_l.italic
|
|
include : create-glyph : glyph-construction
|
|
include [refer-glyph 'longs.italic'] AS_BASE
|
|
apply-transform : Translate shift 0
|
|
include : VBarRight barr 0 CAP
|
|
include : HBarTop hbarleft [mix SB barr 0.65] fbar
|
|
if SLAB : include : tagged 'serifRB' : RightwardBottomSerif barr 0 SideJut
|
|
save 'f_l.italic'
|
|
|
|
italic-variant 'f_l' 0xFB02
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-E : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-Upper-F : FShape RevFShape EFVJutLength
|
|
|
|
glyph-block-export EShape
|
|
define [EShape] : params [top pyBar noSerif] : glyph-construction
|
|
define stroke : adviceBlackness2 2.875 2 CAP
|
|
define xEBarLeft : SB * 1.5
|
|
include : FShape top pyBar true
|
|
include : HBarBottom (xEBarLeft - O) RightSB 0 stroke
|
|
if (SLAB && !noSerif) : begin
|
|
include : LeftwardTopSerif xEBarLeft top SideJut
|
|
include : LeftwardBottomSerif xEBarLeft 0 SideJut
|
|
local { jutTop jutBot } : EFVJutLength top pyBar stroke
|
|
include : DownwardRightSerif RightSB top jutTop
|
|
include : UpwardRightSerif RightSB 0 jutBot
|
|
|
|
glyph-block-export RevEShape
|
|
define [RevEShape] : params [top pyBar noSerif] : glyph-construction
|
|
define stroke : adviceBlackness2 2.875 2 CAP
|
|
define xEBarRight : Width - SB * 1.5
|
|
include : RevFShape top pyBar true
|
|
include : HBarBottom SB (xEBarRight + O) 0 stroke
|
|
if (SLAB && !noSerif) : begin
|
|
include : RightwardTopSerif xEBarRight top SideJut
|
|
include : RightwardBottomSerif xEBarRight 0 SideJut
|
|
local { jutTop jutBot } : EFVJutLength top pyBar stroke
|
|
include : DownwardLeftSerif SB top jutTop
|
|
include : UpwardLeftSerif SB 0 jutBot
|
|
|
|
sketch # turnE
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : EShape CAP
|
|
set-base-anchor 'trailing' (RightSB - markHalfStroke) 0
|
|
save 'E' 'E'
|
|
save 'Epsilon' 0x395
|
|
save 'cyrIe' 0x415
|
|
|
|
create-glyph 'revE' 0x18E : glyph-construction
|
|
set-width Width
|
|
include MarkSet.capital
|
|
include : RevEShape CAP
|
|
save 'turnE' 0x18E
|
|
|
|
sketch # smcpturnE
|
|
include MarkSet.e
|
|
include : EShape XH
|
|
include : FlipAround Middle (XH / 2)
|
|
save 'smcpturnE' 0x2C7B
|
|
|
|
glyph-block Letter-Latin-Lower-E : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
glyph-block-export SmallEShape RevSmallEShape
|
|
|
|
define [SmallEShape top stroke barpos curly] : glyph-construction
|
|
local barbottom : top * [fallback barpos designParameters.eBarPos] - (stroke / 2)
|
|
local hookx (RightSB - OXHook + TailAdjX * TanSlope)
|
|
local hookmiddle : [mix (SB + O) hookx 0.55] + CorrectionOMidS
|
|
local hook : Math.min AHook : if para.isItalic top (stroke / 2 + (top - stroke * 3) / 4)
|
|
include : dispiro
|
|
widths.lhs stroke
|
|
flat (RightSB - OX) barbottom [heading Upward]
|
|
curl (RightSB - OX) (top - SmallSmoothB)
|
|
arcvh
|
|
g4 (Middle - CorrectionOMidS) (top - O)
|
|
archv
|
|
flat (SB + OX) (top - SmallSmoothA)
|
|
curl (SB + OX) (0 + SmallSmoothB)
|
|
hookend O (sw -- stroke)
|
|
g4 (RightSB - OX * [if para.isItalic 0 0.5]) hook
|
|
include : HBarBottom (SB + (stroke / 2) + OX) (RightSB - (stroke / 2) - OX) barbottom stroke
|
|
|
|
sketch # cyrie
|
|
include MarkSet.e
|
|
include : SmallEShape XH [adviceBlackness2 2.875 2 XH]
|
|
save 'e' 'e'
|
|
save 'cyrie' 0x435
|
|
|
|
include : FlipAround Middle (XH / 2)
|
|
save 'turne' 0x1DD
|
|
save 'schwa' 0x259
|
|
save 'cyrschwa' 0x4D9
|
|
|
|
sketch # cyrSchwa
|
|
include MarkSet.capital
|
|
include : SmallEShape CAP [adviceBlackness2 2.875 2 CAP]
|
|
include : FlipAround Middle (CAP / 2)
|
|
save 'Schwa' 0x18F
|
|
save 'cyrSchwa' 0x4D8
|
|
|
|
define [RevSmallEShape top stroke barpos] : glyph-construction
|
|
local barbottom (top * [fallback barpos designParameters.eBarPos] - HalfStroke)
|
|
local hookx SB
|
|
local hookmiddle : [mix (RightSB - O) hookx 0.55] + CorrectionOMidS
|
|
|
|
include : dispiro
|
|
widths.rhs stroke
|
|
flat (SB + OX) barbottom [heading Upward]
|
|
curl (SB + OX) (top - SmallSmoothA)
|
|
arcvh
|
|
g4 Middle (top - O)
|
|
archv
|
|
flat (RightSB - OX) (top - SmallSmoothB)
|
|
curl (RightSB - OX) SmallSmoothA
|
|
hookend O (sw -- stroke)
|
|
g4 (SB + O) AHook
|
|
include : HBarBottom (SB + (stroke / 2)) (RightSB - (stroke / 2)) barbottom stroke
|
|
|
|
sketch # reve
|
|
include MarkSet.e
|
|
include : RevSmallEShape XH [adviceBlackness2 2.875 2 XH]
|
|
save 'reve' 0x258
|
|
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-T : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [TShape top] : glyph-construction
|
|
include : VBar Middle 0 top
|
|
local l : SB + OX * 1.5
|
|
local r : RightSB - OX * 1.5
|
|
include : tagged 'strokeLT' : HBarTop l Middle top
|
|
include : tagged 'strokeRT' : HBarTop Middle r top
|
|
if SLAB : begin
|
|
include : tagged 'serifRT' : DownwardRightSerif r top VJut MVertStroke
|
|
include : tagged 'serifLT' : DownwardLeftSerif l top VJut MVertStroke
|
|
include : tagged 'serifRB' : RightwardBottomSerif Middle 0 MidJutCenter
|
|
include : tagged 'serifRB' : LeftwardBottomSerif Middle 0 MidJutCenter
|
|
|
|
sketch # cyrTe
|
|
include MarkSet.capital
|
|
set-base-anchor 'bottomright' (Middle + HalfStroke * HVContrast) 0
|
|
include : TShape CAP
|
|
|
|
save 'T' 'T'
|
|
save 'Tau' 0x3A4
|
|
save 'cyrTe' 0x422
|
|
|
|
branch
|
|
include : CyrDescender (Middle + HalfStroke * HVContrast) (sideJut -- MidJutCenter - HalfStroke * HVContrast)
|
|
include MarkSet.if
|
|
save 'cyrTedescender' 0x4AC
|
|
|
|
branch
|
|
include : FlipAround Middle (CAP / 2)
|
|
save 'turnT' 0xA7B1
|
|
|
|
branch
|
|
include : HOverlayBar [mix Middle SB 0.8] [mix Middle RightSB 0.8] [mix 0 CAP 0.45]
|
|
save 'Tbar' 0x166
|
|
|
|
branch
|
|
eject-contour 'serifLT'
|
|
eject-contour 'strokeLT'
|
|
include : LeftHook (SB + LeftHook.extension) CAP Middle
|
|
save 'Thookleft' 0x1AC
|
|
|
|
sketch # cyrtedescender.upright
|
|
include MarkSet.e
|
|
include : TShape XH
|
|
save 'cyrte.upright'
|
|
|
|
include : CyrDescender (Middle + HalfStroke * HVContrast) (sideJut -- MidJutCenter - HalfStroke * HVContrast)
|
|
include MarkSet.p
|
|
save 'cyrtedescender.upright'
|
|
|
|
italic-variant 'cyrtedescender' 0x4AD
|
|
|
|
sketch # tau
|
|
include MarkSet.e
|
|
include : HBar SB RightSB (XH - HalfStroke)
|
|
include : VBar Middle 0 XH
|
|
save 'tau' 0x3C4
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-T : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Shared : CreateCommaCaronComposition
|
|
|
|
define tcenter : Middle - TBalance - Stroke * 0.5 * HVContrast
|
|
define dfNarrowT : DivFrame para.diversityF
|
|
define [SmallTShape top bot] : glyph-construction
|
|
local hookx : tcenter + (Width - SB * 2) * 0.8 + Stroke * 0.25 * HVContrast
|
|
local turn : [mix tcenter hookx 0.5] + CorrectionOMidS
|
|
local smb : Math.max Hook ((turn - tcenter) * 1.2)
|
|
|
|
local G : dispiro
|
|
widths.lhs
|
|
flat tcenter top [heading Downward]
|
|
curl tcenter (bot + smb)
|
|
hookend (bot + O) (tight -- !para.isItalic)
|
|
g4 hookx (bot + Hook)
|
|
local g : G.call currentGlyph # Not using include
|
|
set-base-anchor 'bottomright' g.knots.(g.knots.length - 1).x g.knots.(g.knots.length - 1).y
|
|
set-base-anchor 'below' [mix tcenter g.knots.(g.knots.length - 1).x : StrokeWidthBlend 0.375 0.5] bot
|
|
include : dispiro
|
|
widths.rhs
|
|
flat (tcenter + HalfStroke - LongJut + TBalance2 - HalfStroke * TanSlope) XH
|
|
curl (tcenter + HalfStroke + LongJut + TBalance2 - HalfStroke * TanSlope) XH
|
|
|
|
sketch # t.standard
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : SmallTShape CAP 0
|
|
save 't.standard'
|
|
|
|
define [TFlatShape df m ext] : glyph-construction
|
|
local crossLeft : mix 0 SB m
|
|
local crossRight : mix df.width df.rightSB m
|
|
local barleft : [mix crossLeft crossRight 0.42] - Stroke * 0.375 * HVContrast
|
|
local tTurn : Math.max (Hook * 0.9) (Stroke * 1.375) : Math.min Hook (Stroke * 1.75)
|
|
include : union
|
|
dispiro
|
|
widths.rhs
|
|
flat (crossRight) 0
|
|
curl [Math.min (barleft + tTurn) (crossRight - 1)] 0
|
|
archv
|
|
flat barleft tTurn
|
|
curl barleft CAP [heading Upward]
|
|
dispiro
|
|
widths.rhs
|
|
flat (crossLeft - HalfStroke * TanSlope) XH
|
|
curl (crossRight - HalfStroke * TanSlope + ext) XH
|
|
set-base-anchor 'topright' crossRight CAP
|
|
|
|
sketch # t.narrow
|
|
local df : DivFrame para.diversityF
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : TFlatShape df 0.5 0
|
|
save 't.narrow'
|
|
sketch # t.phoneticLeft
|
|
local df : DivFrame 1
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : TFlatShape df 1 0
|
|
save 't.phoneticLeft'
|
|
sketch # t.phoneticLeft.extended
|
|
local df : DivFrame 1
|
|
set-width df.width
|
|
include df.markSet.b
|
|
include : intersection
|
|
TFlatShape df 1 Width
|
|
Rect CAP 0 SB (Middle + Width)
|
|
save 't.phoneticLeft.extended'
|
|
sketch # t.cross
|
|
set-width Width
|
|
include MarkSet.b
|
|
include : VBar Middle 0 CAP
|
|
include : HBarTop (Middle - LongJut) (Middle + LongJut) XH
|
|
save 't.cross'
|
|
select-variant 't' 't'
|
|
|
|
turned 'turnt.standard' nothing 't.standard' Middle (XH / 2) MarkSet.p
|
|
turned 'turnt.cross' nothing 't.cross' Middle (XH / 2) MarkSet.p
|
|
turned 'turnt.narrow' nothing 't.narrow' dfNarrowT.middle (XH / 2) dfNarrowT.markSet.p
|
|
select-variant 'turnt' 0x287 (follow -- 't')
|
|
|
|
CreateCommaCaronComposition 't' 'tcaron' 0x165
|
|
|
|
sketch # tltail
|
|
include MarkSet.if
|
|
include : refer-glyph 't.standard'
|
|
local attach : currentGlyph.gizmo.unapply [query-glyph 't.standard'].baseAnchors.bottomright
|
|
include : VBarRight attach.x 0 attach.y
|
|
include : VerticalHook (attach.x - HalfStroke * HVContrast) 0 (-HookX) Hook
|
|
save 'tltail' 0x1AB
|
|
|
|
sketch # thooktop
|
|
include MarkSet.e
|
|
include : SmallTShape (XH - HalfStroke) 0
|
|
include : VerticalHook (tcenter + HalfStroke * HVContrast) XH HookX (-Hook)
|
|
save 'thooktop' 0x1AD
|
|
|
|
sketch # trtail
|
|
include MarkSet.if
|
|
include : SmallTShape CAP Descender
|
|
save 'trtail' 0x288
|
|
|
|
sketch # tcurlytail
|
|
include MarkSet.b
|
|
local fine : adviceBlackness 3.5
|
|
local rinner : LongJut / 2 - fine / 2
|
|
local x2 : mix SB tcenter 0.4
|
|
local y2 : -fine
|
|
include : HBarTop (tcenter + HalfStroke - LongJut + TBalance2) (tcenter + HalfStroke + LongJut + TBalance2) XH
|
|
include : dispiro
|
|
widths.lhs
|
|
flat tcenter CAP [heading Downward]
|
|
curl tcenter (fine + rinner * 2)
|
|
CurlyTail fine rinner (tcenter+ Stroke * HVContrast) 0 (tcenter + Stroke * HVContrast + LongJut) x2 y2
|
|
|
|
save 'tcurlytail' 0x236
|
|
|
|
sketch # tbar
|
|
include [refer-glyph "t.standard"] AS_BASE
|
|
include : HOverlayBar ([mix Middle SB 0.7] - TBalance * 0.5 - Stroke * 0.25 * HVContrast) ([mix Middle RightSB 0.7] - TBalance * 0.5 - Stroke * 0.25 * HVContrast) [mix 0 XH 0.6]
|
|
save 'tbar' 0x167
|
|
|
|
|
|
glyph-block Letter-Latin-S : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define SOBot OX
|
|
define [SmallSTensionCoeff stroke] : mix [StrokeWidthBlend 1 0.375 stroke] 1 : clamp 0 1 : Math.pow (Width / (UPM * 0.55)) 0.5
|
|
define [SmallSDistCoeff] : Math.min 0.25 (0.1 * [Math.max 1 (Width / HalfUPM)])
|
|
|
|
define [SStroke] : begin
|
|
local stroke : adviceBlackness2 2.875 2 CAP
|
|
local ess : Ess * stroke / Stroke
|
|
define smooth : adviceSSmooth CAP (-1) stroke
|
|
return : dispiro
|
|
widths.lhs stroke
|
|
g4 RightSB (CAP - Hook)
|
|
hookstart (CAP - O) (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 SB (CAP - smooth)
|
|
alsoThru.g2 0.5 0.5 [widths.center ess]
|
|
g4 (RightSB - SOBot) smooth [widths 0 stroke]
|
|
hookend O (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (SB + SOBot) Hook
|
|
|
|
define [RevSStroke] : begin
|
|
local stroke : adviceBlackness2 2.875 2 CAP
|
|
local ess : Ess * stroke / Stroke
|
|
local smooth : adviceSSmooth CAP 0.5 stroke
|
|
return : dispiro
|
|
widths.rhs stroke
|
|
g4 SB (CAP - Hook)
|
|
hookstart (CAP - O) (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 RightSB (CAP - smooth)
|
|
alsoThru.g2 0.5 0.5 [widths.center ess]
|
|
g4 (SB + SOBot) smooth [widths stroke 0]
|
|
hookend O (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (RightSB - SOBot) Hook
|
|
|
|
define [sStroke] : begin
|
|
define stroke : adviceBlackness2 2.875 2 XH
|
|
define ess : adviceBlackness2 3.2 2.2 XH
|
|
define strokeCoeff : StrokeWidthBlend 0 1 stroke
|
|
define smooth : adviceSSmooth XH (-1) stroke
|
|
return : dispiro
|
|
widths.lhs stroke
|
|
g4 (RightSB + OX / 4) (XH - SHook)
|
|
hookstart (XH - O) (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (SB + OX / 8) (XH - smooth)
|
|
SNeck (stroke -- ess) (slantCoeff -- -0.02) (dist -- [SmallSDistCoeff]) (tensionCoeff -- [SmallSTensionCoeff stroke])
|
|
g4 (RightSB - SOBot) (smooth) [widths 0 stroke]
|
|
hookend O (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (SB + SOBot) SHook
|
|
|
|
define [sStrokePhoneticRight] : begin
|
|
define stroke : adviceBlackness2 2.875 2 XH
|
|
define ess : adviceBlackness2 3.2 2.2 XH
|
|
define strokeCoeff : StrokeWidthBlend 0 1 stroke
|
|
define smooth : adviceSSmooth XH (-1) stroke
|
|
return : dispiro
|
|
widths.lhs stroke
|
|
g4 (RightSB + OX / 4) (XH - SHook)
|
|
hookstart (XH - O) (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (SB + OX / 8) (XH - smooth)
|
|
SNeck (stroke -- ess) (slantCoeff -- -0.02) (dist -- [SmallSDistCoeff]) (tensionCoeff -- [SmallSTensionCoeff stroke])
|
|
g4 (RightSB - SOBot) (smooth) [widths 0 stroke]
|
|
arcvh
|
|
flat (Middle - CorrectionOMidS) 0 [widths 0 Stroke]
|
|
curl SB 0
|
|
|
|
define [RevsStroke] : begin
|
|
define stroke : adviceBlackness2 2.875 2 XH
|
|
define ess : adviceBlackness2 3.2 2.2 XH
|
|
define strokeCoeff : StrokeWidthBlend 0 1 stroke
|
|
define smooth : adviceSSmooth XH 0.75 stroke
|
|
return : dispiro
|
|
widths.rhs stroke
|
|
g4 SB (XH - SHook)
|
|
hookstart (XH - O) (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 RightSB (XH - smooth)
|
|
SNeck (stroke -- ess) (slantCoeff -- 0.02) (dist -- [SmallSDistCoeff]) (tensionCoeff -- [SmallSTensionCoeff stroke])
|
|
g4 (SB + SOBot) (smooth) [widths stroke 0]
|
|
hookend O (sw -- stroke) (swItalicAdj -- Stroke)
|
|
g4 (RightSB - SOBot) SHook
|
|
|
|
sketch # S
|
|
include MarkSet.capital
|
|
include : SStroke
|
|
save 'S' 'S'
|
|
save 'cyrDze' 0x405
|
|
|
|
sketch # s
|
|
include MarkSet.e
|
|
include : sStroke
|
|
save 's' 's'
|
|
save 'cyrdze' 0x455
|
|
|
|
sketch # s
|
|
include MarkSet.e
|
|
include : sStrokePhoneticRight
|
|
save 's.phoneticRight'
|
|
|
|
sketch # revS
|
|
include MarkSet.capital
|
|
include : RevSStroke
|
|
save 'revS' 0x1A7
|
|
|
|
sketch # revs
|
|
include MarkSet.e
|
|
include : RevsStroke
|
|
save 'revs' 0x1A8
|
|
save 'cyrghe.italic'
|
|
|
|
sketch # srtail
|
|
include MarkSet.p
|
|
local stroke : [sStroke].call currentGlyph
|
|
local start : currentGlyph.gizmo.unapply stroke.lhsKnots.(stroke.lhsKnots.length - 1)
|
|
|
|
include : create-glyph : glyph-construction
|
|
local sw : adviceBlackness2 2.875 2 XH
|
|
include : refer-glyph "rtailBR"
|
|
apply-transform : Upright
|
|
apply-transform : Translate (start.x + sw * HVContrast) 0
|
|
apply-transform : Italify
|
|
|
|
include : VBarLeft start.x 0 start.y
|
|
|
|
save 'srtail' 0x282
|
|
|
|
sketch # Sswash
|
|
include MarkSet.if
|
|
|
|
local stroke : [SStroke].call currentGlyph
|
|
local start : currentGlyph.gizmo.unapply stroke.lhsKnots.(stroke.lhsKnots.length - 1)
|
|
|
|
local sw : adviceBlackness2 2.875 2 CAP
|
|
include : dispiro
|
|
widths.lhs [adviceBlackness 4.5]
|
|
g4 start.x start.y
|
|
alsoThru 0.15 0.6 important
|
|
flat (RightSB - 1) Descender [widths sw 0]
|
|
curl RightSB Descender
|
|
|
|
save 'Sswash' 0x2C7E
|
|
|
|
sketch # sswash
|
|
include MarkSet.p
|
|
|
|
local stroke : [sStroke].call currentGlyph
|
|
local start : currentGlyph.gizmo.unapply stroke.lhsKnots.(stroke.lhsKnots.length - 1)
|
|
|
|
local sw : adviceBlackness2 2.875 2 XH
|
|
include : dispiro
|
|
widths.lhs [adviceBlackness 4.5]
|
|
g4 start.x start.y
|
|
alsoThru 0.15 0.6 important
|
|
flat (RightSB - 1) Descender [widths sw 0]
|
|
curl RightSB Descender
|
|
save 'sswash' 0x23F
|
|
|
|
sketch # dollar.through
|
|
include MarkSet.capital
|
|
define top : CAP * 0.95
|
|
define bot : CAP * 0.05
|
|
define w : adviceBlackness 3.5
|
|
define fine : adviceBlackness 4
|
|
define smooth : adviceSSmooth (top - bot) (-1) w
|
|
include : dispiro
|
|
widths.lhs w
|
|
g4 RightSB (top - Hook)
|
|
hookstart (top - O)
|
|
g4 SB (top - smooth)
|
|
SNeck w
|
|
g4 RightSB (bot + smooth) [widths 0 w]
|
|
hookend (bot + O)
|
|
g4 SB (bot + Hook)
|
|
include : dispiro
|
|
widths.center w
|
|
flat Middle (top - HalfStroke)
|
|
curl Middle (CAP - Descender / 2) [heading Upward]
|
|
include : dispiro
|
|
widths.center w
|
|
flat Middle (Descender / 2) [heading Upward]
|
|
curl Middle (bot + HalfStroke)
|
|
save 'dollar.open'
|
|
|
|
include : VBar Middle (bot + HalfStroke) (top - HalfStroke) fine
|
|
save 'dollar.through'
|
|
|
|
sketch # dollar.throughcap
|
|
include MarkSet.capital
|
|
define top : CAP * 0.88
|
|
define bot : CAP * 0.12
|
|
define w : adviceBlackness 3.5
|
|
define fine : adviceBlackness 4
|
|
define smooth : adviceSSmooth (top - bot) (-1) w
|
|
include : dispiro
|
|
widths.lhs w
|
|
g4 RightSB (top - Hook)
|
|
hookstart (top - O)
|
|
g4 SB (top - smooth)
|
|
SNeck w
|
|
g4 RightSB (bot + smooth) [widths 0 w]
|
|
hookend (bot + O)
|
|
g4 SB (bot + Hook)
|
|
include : dispiro
|
|
widths.center w
|
|
flat Middle (top - HalfStroke)
|
|
curl Middle (CAP) [heading Upward]
|
|
include : dispiro
|
|
widths.center w
|
|
flat Middle (0) [heading Upward]
|
|
curl Middle (bot + HalfStroke)
|
|
save 'dollar.opencap'
|
|
|
|
include : VBar Middle (bot + HalfStroke) (top - HalfStroke) fine
|
|
save 'dollar.throughcap'
|
|
|
|
select-variant 'dollar' '$'
|
|
|
|
glyph-block Letter-Latin-Z : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # Z
|
|
set-width Width
|
|
include MarkSet.capital
|
|
|
|
local cor : 1.15 * HVContrast
|
|
|
|
include : HBarTop SB RightSB CAP
|
|
|
|
include : ReverseContours : spiro-outline
|
|
corner SB Stroke
|
|
corner (SB + Stroke * cor) Stroke
|
|
corner RightSB (CAP - Stroke)
|
|
corner (RightSB - Stroke * cor) (CAP - Stroke)
|
|
|
|
include : tagged 'strokeBottom' : HBarBottom SB RightSB 0
|
|
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif SB CAP VJut
|
|
include : tagged 'serifRB' : UpwardRightSerif RightSB 0 VJut
|
|
save 'Z.standard'
|
|
save 'Zeta' 0x396
|
|
|
|
branch
|
|
include : refer-glyph 'barOver'
|
|
save 'Zbar' 0x1B5
|
|
branch
|
|
include : refer-glyph 'antiSlashOver'
|
|
save 'Z.withCrossBar'
|
|
|
|
sketch # z
|
|
set-width Width
|
|
include MarkSet.e
|
|
|
|
local cor : 1.2 * HVContrast
|
|
|
|
include : HBarTop SB RightSB XH
|
|
|
|
include : ReverseContours : spiro-outline
|
|
corner SB Stroke
|
|
corner (SB + Stroke * cor) Stroke
|
|
corner RightSB (XH - Stroke)
|
|
corner (RightSB - Stroke * cor) (XH - Stroke)
|
|
|
|
include : tagged 'strokeBottom' : HBarBottom SB RightSB 0
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif SB XH VJut
|
|
include : tagged 'serifRB' : UpwardRightSerif RightSB 0 VJut
|
|
|
|
save 'z.standard'
|
|
branch
|
|
include : refer-glyph 'barOver'
|
|
save 'zbar' 0x1B6
|
|
branch
|
|
include : refer-glyph 'antiSlashOver'
|
|
save 'z.withCrossBar'
|
|
|
|
select-variant 'Z' 'Z'
|
|
select-variant 'z' 'z'
|
|
|
|
if [query-glyph 'Z'] : DoNotDeriveVariants.set [query-glyph 'Z']
|
|
if [query-glyph 'z'] : DoNotDeriveVariants.set [query-glyph 'z']
|
|
|
|
sketch # Zdtail
|
|
include [refer-glyph 'Z'] AS_BASE
|
|
eject-contour 'strokeBottom'
|
|
eject-contour 'serifRB'
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB 0 [heading Rightward]
|
|
curl (RightSB - HookX) 0
|
|
archv
|
|
straight.down.end RightSB (-Hook) [widths.heading 0 Stroke Downward]
|
|
|
|
save 'Zdtail' 0x224
|
|
|
|
sketch # zdtail
|
|
include [refer-glyph 'z'] AS_BASE
|
|
eject-contour 'strokeBottom'
|
|
eject-contour 'serifRB'
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB 0 [heading Rightward]
|
|
curl (RightSB - HookX) 0
|
|
archv
|
|
straight.down.end RightSB (-Hook) [widths.heading 0 Stroke Downward]
|
|
|
|
save 'zdtail' 0x225
|
|
|
|
sketch # Zswash
|
|
include MarkSet.if
|
|
local cor : 1.15 * HVContrast
|
|
|
|
include : HBarTop SB RightSB CAP
|
|
|
|
include : ReverseContours : spiro-outline
|
|
corner SB 0
|
|
corner (SB + Stroke * cor) 0
|
|
corner RightSB (CAP - Stroke)
|
|
corner (RightSB - Stroke * cor) (CAP - Stroke)
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 SB 0
|
|
alsoThru 0.36 0.6 important
|
|
flat (RightSB - 1) Descender
|
|
curl RightSB Descender
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif SB CAP VJut
|
|
|
|
save 'Zswash' 0x2C7F
|
|
|
|
sketch # zswash
|
|
include MarkSet.p
|
|
local cor : 1.2 * HVContrast
|
|
|
|
include : HBarTop SB RightSB XH
|
|
|
|
include : ReverseContours : spiro-outline
|
|
corner SB 0
|
|
corner (SB + Stroke * cor) 0
|
|
corner RightSB (XH - Stroke)
|
|
corner (RightSB - Stroke * cor) (XH - Stroke)
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 (SB - OXHook) 0
|
|
alsoThru 0.36 0.6 important
|
|
flat (RightSB - 1) Descender
|
|
curl RightSB Descender
|
|
|
|
if SLAB : begin
|
|
include : DownwardLeftSerif SB XH VJut
|
|
|
|
save 'zswash' 0x240
|
|
|
|
sketch # Zdesc
|
|
include [refer-glyph 'Z'] AS_BASE
|
|
eject-contour 'serifRB'
|
|
include : VBarRight [mix SB RightSB 1.05] (HalfStroke - LongJut) Stroke
|
|
|
|
save 'Zdesc' 0x2C6B
|
|
|
|
sketch # zdesc
|
|
include [refer-glyph 'z'] AS_BASE
|
|
eject-contour 'serifRB'
|
|
include : VBarRight [mix SB RightSB 1.05] (HalfStroke - LongJut) Stroke
|
|
|
|
save 'zdesc' 0x2C6C
|
|
|
|
sketch # zcurlytail
|
|
include MarkSet.e
|
|
|
|
local fine : adviceBlackness2 5 4 XH
|
|
local rinner : Math.max (XH * 0.04) (fine * 0.1)
|
|
local x2 : mix (SB + Stroke) RightSB 0.3
|
|
local x1 : mix x2 (RightSB - fine - rinner * 1.5) 0.45
|
|
local y2 : -XH * 0.2
|
|
local m1 : RightSB - fine / 2 - rinner * 1.5 + O
|
|
include : HCurlyTail fine Stroke rinner SB m1 (RightSB + fine / 2) x1 x2 y2
|
|
|
|
include : refer-glyph "z"
|
|
eject-contour 'strokeBottom'
|
|
eject-contour 'serifRB'
|
|
save 'zcurlytail' 0x291
|
|
|
|
|
|
glyph-block Letter-Latin-Eszet : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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 * TanSlope
|
|
Math.max (SB + Stroke * 2) [mix SB RightSB (1 / 4)]
|
|
|
|
sketch # eszet.traditional
|
|
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'
|
|
|
|
sketch # eszet.longsslig
|
|
include MarkSet.capital
|
|
|
|
define swOuter : adviceBlackness2 3 3 CAP
|
|
define strokeCoeff : StrokeWidthBlend 0 1 swInner
|
|
define sEndX : Math.max
|
|
SB + swOuter * HVContrast + (RightSB - SB - Stroke) * 0.1
|
|
mix SB RightSB 0.3
|
|
define widthInner : Width - swOuter * HVContrast - (RightSB - SB - Stroke) * 0.1
|
|
define swInner : adviceBlackness2 3 2 XH (widthInner / Width)
|
|
define sTopY : XH + swInner / 8
|
|
define smooth : SmoothBOf (swInner + (widthInner / Width) * ([adviceSSmooth XH (-1) swInner] - swInner)) widthInner
|
|
define sTurnX : Math.max sEndX [mix SB RightSB 0.3]
|
|
define sBotX : Math.max (sEndX + 1) [mix sEndX RightSB 0.30]
|
|
define sTopX : sTurnX + (RightSB - sBotX)
|
|
define sTopHookX : sTopX + 0.5 * swInner * HVContrast
|
|
|
|
include : dispiro
|
|
widths.rhs swOuter
|
|
flat SB 0 [heading Upward]
|
|
curl SB XH
|
|
arcvh
|
|
g4 ([mix SB sTopHookX 0.52] - CorrectionOMidX * swOuter) (CAP - O) [widths.rhs Stroke]
|
|
straight.down.end sTopHookX (sTopY - swInner - O) [widths.heading 0 swInner Downward]
|
|
|
|
include : dispiro
|
|
widths.lhs swInner
|
|
straight.left.start sTopX (sTopY - O) [widths.heading swInner 0 Leftward]
|
|
archv
|
|
g4 sTurnX (XH - smooth)
|
|
SNeck swInner (slantCoeff -- 0.02) (tensionCoeff -- [StrokeWidthBlend 0.99 0.975]) (dist -- 0.025)
|
|
g4 (RightSB - OX) (smooth) [widths 0 swInner]
|
|
hookend O (sw -- swInner) (swItalicAdj -- swOuter)
|
|
g4 (sEndX + OX) SHook
|
|
|
|
piecewise
|
|
para.isItalic : include : VerticalHook (SB + 0.5 * swOuter * HVContrast) 0 (-Hook * 1.2) Hook swOuter
|
|
SLAB : include : LeftwardBottomSerif SB 0 SideJut
|
|
|
|
save 'eszet.longsslig'
|
|
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Upper-AE-OE : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
glyph-block-import Letter-Latin-Upper-F : EFVJutLength
|
|
|
|
sketch # AE
|
|
define df : DivFrame para.diversityM 3
|
|
define eBarPos : designParameters.upperEBarPos SLAB
|
|
define sw : adviceBlackness2 designParameters.lllcrowdedness 3 CAP df.div
|
|
define eleft : df.middle - sw * 0.25 * HVContrast
|
|
define fine : adviceBlackness2 4 3 CAP df.div
|
|
define swVJut : Math.min sw ((df.rightSB - eleft - sw * HVContrast) * (4 / 5))
|
|
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
|
|
local turn : XH * 0.1
|
|
|
|
# A half
|
|
include : dispiro
|
|
widths.rhs sw
|
|
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 fine]
|
|
|
|
include : spiro-outline
|
|
corner (eleft - HalfStroke) CAP
|
|
corner eleft CAP
|
|
corner eleft (CAP - sw)
|
|
include : intersection
|
|
WithTransform [Translate (-O) 0] : spiro-outline
|
|
corner df.leftSB 0 [heading Upward]
|
|
curl df.leftSB (CAP * 0.1) [heading Upward]
|
|
quadcontrols 0 0.3 6 unimportant
|
|
corner (eleft - HalfStroke) CAP [widths.rhs fine]
|
|
corner eleft CAP
|
|
corner eleft 0
|
|
HBarTop 0 eleft (XH / 2) sw
|
|
|
|
# E half
|
|
include : VBarLeft eleft 0 CAP sw
|
|
include : HBarTop (eleft - O) df.rightSB CAP
|
|
include : HBar (eleft - O) (df.rightSB - sw / 4) (CAP * eBarPos)
|
|
include : HBarBottom (eleft - O) df.rightSB 0
|
|
if SLAB : begin
|
|
local { jutTop jutBot } : EFVJutLength CAP eBarPos sw
|
|
include : CenterBottomSerif (df.leftSB + sw / 2 * HVContrast) 0 Jut sw
|
|
include : DownwardRightSerif df.rightSB CAP jutTop swVJut
|
|
include : UpwardRightSerif df.rightSB 0 jutBot swVJut
|
|
save 'AE' 0xC6
|
|
save 'cyrAE' 0x4D4
|
|
|
|
define [OEShape top df] : glyph-construction
|
|
define eBarPos : designParameters.upperEBarPos SLAB
|
|
define sw : adviceBlackness2 designParameters.lllcrowdedness 3 top df.div
|
|
define eleft : df.middle - sw * [if SLAB (1 / 3) (1 / 4)] * HVContrast
|
|
define swVJut : Math.min sw ((df.rightSB - eleft - sw * HVContrast) * (4 / 5))
|
|
|
|
# O half
|
|
include : dispiro
|
|
widths.lhs sw 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 sw
|
|
include : HBarTop (eleft - O) df.rightSB top sw
|
|
include : HBar (eleft - O) (df.rightSB - sw / 4) (top * 0.54) sw
|
|
include : HBarBottom (eleft - O) df.rightSB 0 sw
|
|
|
|
if SLAB : begin
|
|
local { jutTop jutBot } : EFVJutLength top eBarPos sw
|
|
include : DownwardRightSerif df.rightSB top jutTop swVJut
|
|
include : UpwardRightSerif df.rightSB 0 jutBot swVJut
|
|
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Lower-AE-OE : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
define [GetSm df stroke] : begin
|
|
local sma : SmoothAOf [Math.max (stroke * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
local smb : SmoothBOf [Math.max (stroke * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
return { sma smb }
|
|
|
|
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 * TanSlope
|
|
local barbottom (XH * designParameters.eBarPos - stroke / 2)
|
|
local { sma smb } : GetSm df stroke
|
|
|
|
include : difference
|
|
union
|
|
dispiro
|
|
widths.lhs stroke
|
|
flat (df.rightSB - OX * 2) barbottom [heading Upward]
|
|
curl (df.rightSB - OX * 2) (XH - smb)
|
|
arcvh
|
|
g4 eMiddle (XH - O)
|
|
archv
|
|
flat eLeft (XH - sma)
|
|
curl eLeft smb
|
|
hookend O (tight -- true) (sw -- stroke)
|
|
g4 (df.rightSB - OX * 2) (AHook + stroke * TanSlope) [heading Upward]
|
|
HBarBottom (eLeft + stroke / 2) (df.rightSB - OX * 2 - stroke / 2) barbottom stroke
|
|
Rect barbottom (barbottom - XH * 0.05) eMiddle df.width
|
|
|
|
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 smb } : GetSm df stroke
|
|
|
|
include : dispiro
|
|
widths.rhs stroke
|
|
g4 (df.leftSB + OX) (XH - AHook - stroke * TanSlope) [heading Upward]
|
|
hookstart (XH - O) (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
|
|
local { sma smb } : GetSm df stroke
|
|
|
|
include : OShape XH 0 (df.leftSB + OX) (abarRight + OX) stroke sma smb
|
|
|
|
define [ueupart df] : glyph-construction
|
|
local stroke : adviceBlackness2 2.875 3 XH df.div
|
|
local abarRight : df.middle + stroke / 2 * HVContrast
|
|
local { sma smb } : GetSm df stroke
|
|
|
|
include : nShoulder
|
|
left -- abarRight
|
|
right -- (df.rightSB - OX)
|
|
stroke -- stroke
|
|
sma -- smb
|
|
smb -- smb
|
|
include : FlipAround (df.width / 2) (XH / 2)
|
|
|
|
sketch # ae
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : aeapart df
|
|
include : aeepart 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 : oeopart df
|
|
include : aeepart df
|
|
save 'oe' 0x153
|
|
turned nothing 0x1D14 'oe' [DivFrame para.diversityM].middle (XH / 2)
|
|
|
|
create-glyph 'ue' 0x1D6B : glyph-construction
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.e
|
|
include : create-glyph : glyph-construction
|
|
include : ueupart df
|
|
include : aeepart df
|
|
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-OU : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # OU
|
|
include MarkSet.capital
|
|
include : OShape (CAP * HBarPos + HalfStroke) 0 SB RightSB nothing SmoothA SmoothB
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB CAP [heading Downward]
|
|
curl SB (CAP * HBarPos - O - HalfStroke + SmoothB)
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) (CAP * HBarPos - O - HalfStroke + (Stroke * (1 - CThin))) [widths.lhs (Stroke * CThin)]
|
|
archv
|
|
flat RightSB (CAP * HBarPos - O - HalfStroke + SmoothA) [widths.lhs]
|
|
curl RightSB CAP [heading Upward]
|
|
|
|
save 'OU' 0x222
|
|
|
|
sketch # ou
|
|
include MarkSet.b
|
|
local bar : StrokeWidthBlend (XH * 0.9) XH
|
|
include : OShape bar 0 SB RightSB
|
|
include : dispiro
|
|
widths.lhs
|
|
flat SB CAP [heading Downward]
|
|
curl SB (bar - O - Stroke + SmoothB)
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidS) (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
|
|
|
|
|
|
glyph-block Letter-Latin-IJ : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # IJ
|
|
include MarkSet.capital
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "I.straight"
|
|
apply-transform : Translate (SB - Middle + HalfStroke * HVContrast) 0
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "J.shorthook"
|
|
apply-transform : Translate JBalance2 0
|
|
|
|
save 'IJ' 0x132
|
|
|
|
sketch # ij
|
|
include MarkSet.if
|
|
include : create-glyph : glyph-construction
|
|
include [refer-glyph 'dotlessi.straight'] AS_BASE
|
|
include : refer-glyph "dotAbove"
|
|
apply-transform : Translate (SB * 1.5 - Middle + HalfStroke * HVContrast) 0
|
|
include : create-glyph : glyph-construction
|
|
include [refer-glyph 'dotlessj.straight'] AS_BASE
|
|
include : refer-glyph "dotAbove"
|
|
apply-transform : Translate (RightSB - SB * 0.5 - Middle - JBalance - HalfStroke * HVContrast) 0
|
|
save 'ij' 0x133
|
|
|
|
|
|
glyph-block Letter-Latin-Ezh : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
glyph-block-export EzhShape
|
|
define [EzhShape] : params [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
|
|
|
|
include : ReverseContours : spiro-outline
|
|
corner ezhLeft yMidBar
|
|
corner (ezhLeft + Stroke * cor) (yMidBar - HalfStroke)
|
|
corner (ezhLeft + Stroke * cor) yMidBar
|
|
corner ezhRight (top - Stroke)
|
|
corner (ezhRight - Stroke * cor) (top - Stroke)
|
|
|
|
include : dispiro
|
|
widths.rhs
|
|
flat ezhLeft yMidBar [heading Rightward]
|
|
curl (Middle - CorrectionOMidS) yMidBar
|
|
archv
|
|
if hookless
|
|
: then : list
|
|
g4.down.mid (RightSB - OX) [mix yMidBar bot hookless] [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
|
|
|
|
glyph-block-export RevEzhShape
|
|
define [RevEzhShape] : params [top bot pleft pright hookless [sma SmallSmoothA] [smb SmallSmoothB] [diagCoeff 1.2] [pyBar 0.6]] : glyph-construction
|
|
local cor : diagCoeff * HVContrast
|
|
local yMidBar : RevEzhShape.yMidBar top bot pyBar
|
|
local ezhRight : mix SB RightSB [fallback pright 0.8]
|
|
local ezhLeft : mix SB RightSB [fallback pleft 0.075]
|
|
include : HBarTop ezhLeft RightSB top
|
|
|
|
include : spiro-outline
|
|
corner ezhRight yMidBar
|
|
corner (ezhRight - Stroke * cor) (yMidBar - HalfStroke)
|
|
corner (ezhRight - Stroke * cor) yMidBar
|
|
corner ezhLeft (top - Stroke)
|
|
corner (ezhLeft + Stroke * cor) (top - Stroke)
|
|
|
|
include : dispiro
|
|
widths.lhs
|
|
flat ezhRight yMidBar [heading Leftward]
|
|
curl (Middle + CorrectionOMidS) yMidBar
|
|
archv
|
|
if hookless
|
|
: then : list
|
|
g4.down.mid (SB + OX) [RevEzhShape.yLoopLeft top bot pyBar sma smb]
|
|
: else : list
|
|
g4 (SB + OX) [RevEzhShape.yLoopLeft top bot pyBar sma smb]
|
|
hookend bot
|
|
g4 RightSB (bot + Hook * ((top - bot) / CAP))
|
|
if SLAB : begin
|
|
include : DownwardRightSerif RightSB top VJut
|
|
set RevEzhShape.yMidBar : lambda [top bot pyBar] : mix bot top pyBar
|
|
set RevEzhShape.yLoopLeft : lambda [top bot pyBar sma smb]
|
|
mix [RevEzhShape.yMidBar top bot pyBar] bot (sma / (sma + smb))
|
|
|
|
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 : adviceBlackness2 5 3 (XH - Descender)
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Glottal-Stop : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # glottalstop
|
|
include MarkSet.b
|
|
include : dispiro
|
|
widths.rhs
|
|
g4 SB (CAP - Hook)
|
|
hookstart (CAP - O)
|
|
g4 RightSB (CAP - [adviceGlottalStopSmooth CAP 1])
|
|
alsoThru.g2 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 (CAP - O)
|
|
g4 SB (CAP - [adviceGlottalStopSmooth CAP (-1)])
|
|
alsoThru.g2 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 (XH - O)
|
|
g4 RightSB (XH - [adviceGlottalStopSmooth XH 1])
|
|
alsoThru.g2 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 - TanSlope * (15 - (Width / 500) * 12) * [clamp 0 1 : linreg 126 1 135 0.5 Stroke])
|
|
include : dispiro
|
|
widths.lhs
|
|
g4 RightSB (XH - Hook)
|
|
hookstart (XH - O)
|
|
g4.down.mid SB (XH - smooth)
|
|
alsoThru.g2 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 (CAP - O)
|
|
g4 RightSB (CAP - [adviceGlottalStopSmooth CAP 1])
|
|
alsoThru.g2 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 (CAP - O)
|
|
g4 SB (CAP - [adviceGlottalStopSmooth CAP (-1)])
|
|
alsoThru.g2 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 [refer-glyph 'glottalstop'] AS_BASE
|
|
include : HOverlayBar (Middle - LongJut * 0.6) (Middle + LongJut * 0.6) (CAP * 0.25)
|
|
|
|
save 'glottalstopbar' 0x2A1
|
|
|
|
sketch # revglottalstopbar
|
|
include [refer-glyph 'revglottalstop'] AS_BASE
|
|
include : HOverlayBar (Middle - LongJut * 0.6) (Middle + LongJut * 0.6) (CAP * 0.25)
|
|
save 'revglottalstopbar' 0x2A2
|
|
|
|
|
|
glyph-block Letter-Latin-Eth : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Thorn : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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 - CorrectionOMidS) bowlTop
|
|
archv
|
|
g4 (RightSB - O) turn
|
|
arcvh
|
|
flat (RightSB - turnRadius + CorrectionOMidS) 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 : refer-glyph "b"
|
|
eject-contour 'serifLB'
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "p"
|
|
eject-contour 'bowl'
|
|
eject-contour 'serifLT'
|
|
include MarkSet.if
|
|
save 'thorn' 0xFE
|
|
|
|
sketch # sho
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "b"
|
|
eject-contour 'serifLB'
|
|
eject-contour 'serifLT'
|
|
include : create-glyph : glyph-construction
|
|
include : refer-glyph "p"
|
|
eject-contour 'bowl'
|
|
eject-contour 'serifLT'
|
|
eject-contour 'serifLB'
|
|
include MarkSet.if
|
|
save 'sho' 0x3F8
|
|
|
|
glyph-block Letter-Latin-Hwair : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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 : tagged 'serifLB' : CenterBottomSerif (df.leftSB + df.mvs / 2 * HVContrast) 0 jut
|
|
save 'hwair' 0x195
|
|
|
|
|
|
glyph-block Letter-Latin-Gha : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
sketch # Gha
|
|
local df : DivFrame para.diversityM 3
|
|
set-width df.width
|
|
include df.markSet.capital
|
|
local abarRight : df.middle + df.mvs / 2 * HVContrast
|
|
local sma : SmoothAOf [Math.max (df.mvs * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
local smb : SmoothBOf [Math.max (df.mvs * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
include : OShape CAP 0 df.leftSB abarRight df.mvs sma smb
|
|
include : VBarRight (df.rightSB - O) Descender CAP df.mvs
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.middle (CAP - smb) [heading Rightward]
|
|
curl (df.middle + 1) (CAP - smb) [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
|
|
local sma : SmoothAOf [Math.max (df.mvs * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
local smb : SmoothBOf [Math.max (df.mvs * 1.125) (SmallSmooth * 0.6 * df.div)] (Width * df.div)
|
|
include : OShape XH 0 df.leftSB abarRight df.mvs sma smb
|
|
include : VBarRight (df.rightSB - O) Descender XH df.mvs
|
|
include : dispiro
|
|
widths.lhs df.mvs
|
|
flat df.middle (XH - smb) [heading Rightward]
|
|
curl (df.middle + 1) (XH - smb) [heading Rightward]
|
|
alsoThru 0.5 0.15
|
|
g4 (df.rightSB - O - df.mvs * HVContrast) XH [widths 0 df.mvs]
|
|
save 'gha' 0x1A3
|
|
|
|
|
|
glyph-block Letter-Latin-Wynn : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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) (top - [SmoothBOf (0.3 * (top - bot)) Width])
|
|
alsoThru 0.25 0.45 important
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Yogh : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-RamsHorn : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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 - TanSlope * 0.5)) [widths hf hf]
|
|
arcvh
|
|
g4 (Middle + CorrectionOMidX * hf * 2) (bottom + hf)
|
|
archv
|
|
g4 (Middle - d + hf) (bottom + d * (1 + TanSlope * 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 : union
|
|
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]
|
|
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
|
|
save 'latinayin' 0x1D25
|
|
|
|
|
|
glyph-block Letter-Latin-Rhotic : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
glyph-block-export ErTail
|
|
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
|
|
|
|
|
|
glyph-block Letter-Latin-Bidental-Percussive : begin
|
|
glyph-block-import CommonShapes
|
|
glyph-block-import Overmarks
|
|
|
|
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
|