From 980ad5b78d69aa8abfb093c7e6729b0024ce0b49 Mon Sep 17 00:00:00 2001 From: Hans Hagen Date: Mon, 11 Jan 2021 18:09:53 +0100 Subject: 2021-01-11 16:30:00 --- .../documents/general/manuals/luametatex.pdf | Bin 1383227 -> 1383078 bytes .../manuals/followingup/followingup-fonts.tex | 593 ++++++++++++++++----- .../manuals/followingup/followingup-style.tex | 2 + .../general/manuals/luametatex/luametatex.tex | 2 +- 4 files changed, 459 insertions(+), 138 deletions(-) (limited to 'doc') diff --git a/doc/context/documents/general/manuals/luametatex.pdf b/doc/context/documents/general/manuals/luametatex.pdf index 52c93219f..635e56000 100644 Binary files a/doc/context/documents/general/manuals/luametatex.pdf and b/doc/context/documents/general/manuals/luametatex.pdf differ diff --git a/doc/context/sources/general/manuals/followingup/followingup-fonts.tex b/doc/context/sources/general/manuals/followingup/followingup-fonts.tex index a3059847e..2f7320b12 100644 --- a/doc/context/sources/general/manuals/followingup/followingup-fonts.tex +++ b/doc/context/sources/general/manuals/followingup/followingup-fonts.tex @@ -6,104 +6,376 @@ \startchapter[title={Scaled fonts}] -Although \CONTEXT\ is quite efficient with fonts there is always room for -improvement. However, after years of fine tuning the font mechanisms there was -not that much room left. On the average, given that \TEX\ is mostly about fonts, -what we have is quite okay, but for some scripts, like \CJK\ the demands on -resources can be rather high. This made me think of a different approach to -scaling. Nowadays fonts seldom come in design sizes. Also, in \CONTEXT\ \MKIV\ -and therefore \LMTX\ we always had so called dynamic features: apply additional -features locally, although that comes with a small penalty in performance, it -saves additional font instances. It is a good approach for the occasional small -stretch of glyphs, like small capped logos and such. - -Using a font at a larger size means that we need to provide \TEX\ with the right -dimensions: it needs them for instance for for braking paragraph into lines or -wrapping text in boxes. The amount of information that \TEX\ needs is small: only -dimensions. Of course there are ligatures and kerns but in so called base mode we -seldom have many. The data needed for node mode (used for more complex \OPENTYPE\ -fonts) can be shared and lives at the \LUA\ end. But even then the character -table is copied and scaled. Actually, we seldom need that information but it is -good to have it and in the case of virtual fonts it is needed. But, when a font -is used at a different size, and al the features are the same, we can think of -a different approach. - -That approach is tagged as \quote {dynamic font scaling}, which means that we -don't need to define a new font instance when the same feature set is used. Or -course in addition to this features one can still use the dynamic features. This -means that for instance chapter titling can use the bodyfont instance and just -apply additional scaling. Although for a normal run the number of loaded fonts is -normally small, and the number of instances also isn't that impressive it can -happen in a large document that you end up with a few dozen. That number can now -be reduced to half a dozen. - -Of course there can be side effects, which is why it's currently tagged as -experimental. There is also a small performance hit because we now need to track -it but that is gained back because we load less fonts and have less glyph runs. - -So how does it work? Here is an example: +\startsection[title={History}] + +The infrastructure for fonts makes for a large part of the code of any \TEX\ +macro package. We have to go back in time to understand why. When \TEX\ showed +up, fonts were collections of bitmaps and measures. There were at most 256 glyphs +in a font and in order to do its job, \TEX\ needed to know (and still needs to +know) the width, height and depth of glyphs. If you want ligatures it also needs +to know how to construct them from the input and when you want kerning there has +to be additional information about what neighboring glyphs need a kern in +between. Math is yet another subtask that demands extra information, like chains +of glyphs that grow in size and if needed even recipes of how to construct large +shapes from smaller ones. + +Fonts come in sizes, and for instance Latin Modern has quite a few variants where +the shapes are adapted to the size. This means that when you need a 9pt regular +shape alongside a 12pt one, two fonts have to be loaded. This is quite visible in +math where we have three related sizes: text, script and scriptscript, grouped in +so called families. + +Plenty has been written (in various documents that come with \CONTEXT) about how +this all works together and how it impacts the design of the system, so here I +just give a short summary of what a font system has to deal with. + +\startitemize +\startitem + In a bodyfont setup different sizes (9pt, 10pt, 12pt) can have their own + specific set of fonts. This can result in quite some definitions that relate + to the style, like regular, bold, italic, bolditalic, slanted and + boldslanted, etc. When possible loading the fonts is delayed. +\stopitem +\startitem + Some font designs have different shapes per bodyfont size. A minor + complication is that when one is missing some heuristic best match choice + might be needed. +\stopitem +\startitem + Within a bodyfont size we distinguish size variants. We can go smaller (x and + xx), for instance when we use sub- and superscripts in text, or we can go + larger, for instance in titling (a, b, c, d, \unknown). Fortunately most of + the loading of these can be delayed too. +\stopitem +\startitem + When instances are not available, scaling can be used, as happens for + instance with 11pt in Computer Modern. Actually, this is why in \CONTEXT\ we + default to 12pt, because the scaled versions didn't look as nice as the + others. +\stopitem +\startitem + Special features, like smallcaps or oldstyle numerals, can demand their own + definitions. More loading and automatic definitions can be triggered by sizes + needed in for instance scripts and titling. +\stopitem +\startitem + A document can have a mixed setup, that is: use different font designs in one + document, so some kind of namespace subsystem is needed. +\stopitem +\startitem + In traditional eight bit engine the dependency of hyphenation on the encoding + of a font can result in the necessity to load a font multiple times in + different encodings, something that depends on the language mix used. +\stopitem +\startitem + In the more modern \OPENTYPE\ fonts combinations of features can demand + additional instances (one can thing of language|/|script combinations, + substitutions in base mode, special effects like boldening, color fonts, + etc.). +\stopitem +\startitem + Math is complicated by the fact that alphabets come from different fonts + (sometimes a font has several alphabets which means that some mapping can be + needed). Operating on the size, shape, encoding and style axes puts some + demands on the font system. Add to this (often) partial (due to lack of + fonts) bold support and it gets even more complicated. +\stopitem +\startitem + There is additional math auto|-|definition and loading code for the sizes + used in text scripts and titling. +\stopitem +\stopitemize + +All this has resulted in a pretty complex subsystem. Although going \OPENTYPE\ +(and emulated \OPENTYPE\ with \TYPEONE\ fonts as we do in \MKIV) removes some +complications, like encodings, it does also add complexity because of the many +possible font features, either or not dependent on script and language. + +Also, in order to let a font subsystem not impact performance to much, let alone +extensive memory usage, the \CONTEXT\ font subsystem is rather optimized. The +biggest burden comes from fonts that have a dynamic (adaptive) definition because +then we need to do quite a bit of testing per font switch, but even that has +always been rather fast. + +\stopsection + +\startsection[title={Reality}] + +In \MKIV\ and therefore also in \LMTX\ more font magic happens. The initial node +lists that makes up a box or paragraph can get manipulated in several ways and +often fonts are involved. The mentioned font features can be defines static (as +part of the definition) or dynamic (resolved on the spot at the cost of some +overhead). Characters can be remapped, fonts can be replaced. The math subsystem +in \MKIV\ was different right from the start: we use a limited number of families +(regular, bold, l2r and r2l), and stay abstract till the moment we need to deal +with the specific alphabets. But still, in \MKIV, we have the families with three +fonts. + +In the \LUAMETATEX\ manual we show some math magic and we do so for different +fonts. As a side effect, we set up half a dozen bodyfont collections. Even with +delayed and shared font loading, we end up with 158 instances but quite a bit of +them are math fonts, at least six per bodyfont size: regular and bold (boldened) +text, script and scriptscript. Of course most are just copies with different +scaling that reuse already loaded resources. + +If we look at the math fonts that we use today, there is however quite some +overlap. It starts with a text font. From that script and scriptscript variants +are derived, but often these variants use many text size related shapes too. Some +shapes get alternatives (from the \type {ssty} feature), and the whole clone get +scaled. But, much of the logic of for instance extensibles is the same. + +A similar situation happens with for instance large \CJK\ fonts: there are hardly +any advanced features involved there, so any size is basically a copy with scaled +dimensions, and these fonts can be real huge! + +Actually, when we talk about features, in many cases in \CONTEXT\ you don't +define them as part of the font. For instance small caps can best be triggered by +using a dynamic feature: applied to a specific stretch of text. When the font +handler does its work there are actually four cases: no features get applied, +something that for instance happens with most monospaced fonts, base mode is +used, which means that the \TEX\ machinery takes care of constructing ligatures +and injecting kerns, and node mode, where \LUA\ handles the features. The fourth +case is a special case of node mode where a different features set is applied. +\footnote {We also have so called plug mode where an external rendered can do the +work but that one is only around for some experiments during Idris' font +development.} At the cost of some extra overhead (for each node mode run) dynamic +features are quite powerful and save quite some memory and definitions. The +overhead comes from much more testing regarding the font we deal with because +suddenly the same font can demand different treatments, depending on what dynamic +features is active. + +Although the font handling is responsible for much of the time spent in \LUA, it is +still reasonable given what has to be done. Actually, because we have an extensible +system, it's often the extensions that takes additional runtime. Flexibility comes +at a price. + +\stopsection + +\startsection[title={Progress}] + +At some point I started playing with realtime glyph scaling. Here realtime means that +it doesn't depend on the font definition. To get an idea, here is an example: \startbuffer -\definescaledfont[MyLargerFontA][scale=2000,style=bold] - -test {\MyLargerFontA test} test +test {\glyphxscale 2500 test} test \stopbuffer \typebuffer -This gives: - \getbuffer -You can also say: +The glyphs in the current font get scaled horizontally without the need for an extra +font instance. Now, this kind of trickery puts some constraints on the font handling, +as is demonstrated in the next example. We use Latin Modern because that font has +all these ligatures: \startbuffer -\definescaledfont[MyLargerFontB][xscale=1200,yscale=2000,style=bold] - -test {\MyLargerFontB test} test +\definedfont[lmroman-regular*default]% +e{\glyphxscale 2500 ff}icient +ef{\glyphxscale 2500 f}icient +ef{\glyphxscale 2500 fi}cient +e{\glyphxscale 2500 ffi}cient \stopbuffer \typebuffer -Which scaled the over two axis: +{\getbuffer} + +So, in order to deal with this kind of scaling, we now operate not only on the +font (id) and dynamic feature axes, but also on the scales of which we have three +variants: glyph scale, glyph xscale and glyph y scale). There is actually also a +state dimension but we leave that for now. Think of flagging glyphs as initial or +final. This brings the number of axis to six. It is important to stress that in +these examples the same font instance is used! + +Just for the record: there are several approaches to switching fonts possible but +for now we stick to a simple font id switch plus glyph scale settings at the +\TEX\ end. A variant would be to introduce a new mechanism where id's and scales +go together but for now I see no real gain in that. + +\stopsection + +\startsection[title={Math}] + +Given what is written in the previous sections, a logical question is if we can +apply scaling to math and the answer is \quotation {yes, we can}. But we actually +go a bit further and that is partly due to some other properties of the engine. + +From \PDFTEX\ the \LUATEX\ engines inherited character protrusion and glyph +expansions, aka hz. However, where in \PDFTEX\ copies of the font are made that +carry the expanded dimensions, in \LUATEX\ at some point this was replaced by an +expansion field in the glyph and kern nodes. So, instead of changing the font id +of expanded glyphs, the same id is used but with the applied expansion factor set +in the glyph. A side effect was that in places where dimensions are needed, calls +to functions that calculate the expanded widths on request (as these can change +during linebreak calculations) in combination with accessing font dimensions +directly, we now always use accessor functions. This level of abstraction is even +more present in \LUAMETATEX. This means that we have an uniform interface to +fonts and as a side effect scaling is to be dealt with in only a few places in +the code. + +Now, in math we have a few more complications. First of all, we have three sizes +to consider and we also have lots of parameters that depend on the size. But, as +I wanted to be able to apply scaling to math, the whole machinery was also +abstracted in a way that, at the cost of some extra overhead, made it easier to +work with scaled glyph properties. This means that we can stick to loading only +one bodyfont size of math (note that each math family has three sizes, where the +script and script sizes can have different, fine tuned, shapes) and just scale +that on demand. + +Once all that was in place it was a logical next step to see if we could actually +stick to one instance. Because in \LUAMETATEX\ we try to load fonts efficiently +we store only the minimally needed information at the \TEX\ end. A font with no +math therefore has less data per glyph. Again, this brings some abstraction that +actually helped to implement the one instance mechanism. A math glyph has +optional lists of increasing sizes and vertical or horizontal extensibles. So +what got added was an optional chain of smaller sizes. If a character has 3 +different glyphs for the three sizes, the text glyph has a pointer to the script +glyph which in turn has a pointer to the scriptscript glyph. This means that when +the math engine needs a specific character at a given size (text, script, +scriptscript) we just follow that chain. + +In an \OPENTYPE\ math font the script and scriptscript sizes are specified as +percentages of the text size. So, when the dimensions of a glyph are needed, we +just scale on the fly. Again this adds some overhead but I'm pretty sure that no +user will notice this. + +So, to summarize: if we need a character at scriptscript size, we access the text +size glyph, check for a pointer to a script size, go there, and again check for a +smaller size. We just use what fits the bill. And, when we need dimensions we +just scale. In order to scale we need the relative size, so we need to set that +up when we load the font. Because in \CONTEXT\ we also can assemble a virtual +\OPENTYPE\ font from \TYPEONE\ fonts, it was actually that (old) compatibility +feature that took most time to adapt, not so much because it is complicates but +because in \LMTX\ we have to bypass some advanced loading mechanisms. + +The end result is that for math we now only need to define two fonts per bodyfont +setup: regular and bold at the natural scale (normally 10pt) and we share these +for all sizes. It is because of this and what we describe in the next section +that the 158 instances for the \LUAMETATEX\ manual can now be brought down to 30. + +\stopsection + +\startsection[title={Text}] + +Sharing instances in text mode is relatively simple, although we do have to keep +in mind that these are extra axis when dealing with font features: two +neighboring glyphs with the same font id and dynamics but with different scales +are effectively from different fonts. + +Another complication is that when we use font fallbacks (read: take missing +glyphs from another font) we no longer have a dedicated instance but use a shared +one. This in itself if not a problem but we do need to handle specified relative +scales. This was not that hard to patch in \CONTEXT\ \LMTX. + +We can enforce aggressive font sharing with: -\getbuffer +\starttyping +\enableexperiments[fonts.compact] +\stoptyping + +After that we often use less instances. Just to give an idea, on the \LUAMETATEX\ +manual we get these stats: + +\starttyping +290 pages, 10.8 sec, 292M lua, 99M tex, 158 instances +290 pages, 9.5 sec, 149M lua, 35M tex, 30 instances +\stoptyping -The low level implementation uses the two variables \type {\glyphxscale} and -\type {\glyphyscale} that take a number. As with other \TEX\ scaling related -variables, a value of 1000 represents 1.0 so we have three digits precision. +So, we win on all fronts when we use this glyph scale mechanism. The magic +primitive that deals with this is \type {\glyphscale} which accepts a number, +where \type {1200} and \type {1.2} both mean scaling to 20\percent\ more than +normal. But one can best not use this primitive directly. -Because we just scale, the next also works: +A specific font can be defined using the \type {\definefont} command. In \LMTX\ a +regular scaler can be followed by two scale factors. The nest example +demonstrates this: \startbuffer -test {\MyLargerFontB test {\em test} test} test +\definefont[FooA][Serif*default @ 12pt 1800 500] +\definefont[FooB][Serif*default @ 12pt 0.85 0.4] +\definefont[FooC][Serif*default @ 12pt] + +\definetweakedfont[runwider] [xscale=1.5] +\definetweakedfont[runtaller][yscale=2.5,xscale=.8,yoffset=-.2ex] + +{\FooA test test \runwider test test \runtaller test test}\par +{\FooB test test \runwider test test \runtaller test test}\par +{\FooC test test \runwider test test \runtaller test test}\par \stopbuffer \typebuffer -The nested emphasis still works: +We also use the new \type {\definetweakedfont} command here. This example not +only shows the two scales but also introduces the offset. \getbuffer -For now we only have a simple user interface but it might eventually be more -integrated. For instance, we can consider defining \type {\tfa} and friends this -way. +Here is another one: + +\startbuffer +\definetweakedfont[squeezed] [xscale=0.9] +\definetweakedfont[squeezed] [xscale=0.9] + +\startlines +$a = b^2 + \sqrt{c}$ +{\squeezed $a = b^2 + \sqrt{c}$} +\stoplines +\stopbuffer + +\typebuffer + +\getbuffer -In order to make it useful, math is also supported: +Watch this: \startbuffer -\definescaledfont[MyLargerFontC][xscale=1200,yscale=2000] +\startcombination[4*1] + {\bTABLE + \bTR \bTD foo \eTD \bTD[style=\squeezed] $x = 1$ \eTD \eTR + \bTR \bTD oof \eTD \bTD[style=\squeezed] $x = 2$ \eTD \eTR + \eTABLE} + {local} + {\bTABLE[style=squeezed] + \bTR \bTD $x = 1$ \eTD \bTD $x = 3$ \eTD \eTR + \bTR \bTD $x = 2$ \eTD \bTD $x = 4$ \eTD \eTR + \eTABLE} + {global} + {\bTABLE[style=\squeezed\squeezed] + \bTR \bTD $x = 1$ \eTD \bTD $x = 3$ \eTD \eTR + \bTR \bTD $x = 2$ \eTD \bTD $x = 4$ \eTD \eTR + \eTABLE} + {multiple} +\stopcombination +\stopbuffer -test {\MyLargerFontC test $\sqrt{x}$ test} test +\typebuffer + +\startlinecorrection +\getbuffer +\stoplinecorrection + +An additional style parameter is also honored: + +\startbuffer +\definetweakedfont[MyLargerFontA][scale=2000,style=bold] +test {\MyLargerFontA test} test \stopbuffer \typebuffer -gives: +This gives: \getbuffer -You can actually use negative values, as is demonstrated in the following +Just for the record: the Latin Modern fonts, when set up to use design sizes, will +still use the specific size related files. + +\stopsection + +\startsection[title={Hackery}] + +You can actually use negative scale values, as is demonstrated in the following code: \startbuffer @@ -131,45 +403,8 @@ gives: \getbuffer \stoplinecorrection -Because loading and switching fonts in \CONTEXT\ is rather efficient, the gain in -performance is less than you expect. After all, not all time is spent on fonts. Of -course for huge \CJK\ fonts it does make a difference. But, when we do a massive switch -to a different body font, we can save a little more. Think of definitions like: - -\starttyping -\definescaledfontbody[BigBodyFont] [1.200] -\definescaledfontbody[VeryBigBodyFont] [1.440] -\definescaledfont [MyLargerFont] [xscale=1.200,yscale=2.000] -\stoptyping - -And then: - -\starttyping -\setuphead[title][style=\MyLargerFont\bf] -\stoptyping - -The savings in runtime can be quite noticeable now, for instance this: - -\starttyping -\dorecurse {100} { - \starttitle[title={Test #1] - \samplefile{ward}\par - \start \bf - \samplefile{ward}\par - \stop - \start \BigBodyFont \bf - \samplefile{ward}\par - \stop - \stoptitle -} -\stoptyping - -Speeds up a bit for Pagella and even more when we use Cambria. Keep in mind that -that a body font switch also involves setting up some math. Anyway, as a proof of -concept it worked out well. - -Glyphs can have offsets and these are used for implementing \OPENTYPE\ features. However, -they are also available at the \TEX\ end. Take this +Glyphs can have offsets and these are used for implementing \OPENTYPE\ features. +However, they are also available at the \TEX\ end. Take this \startbuffer \ruledhbox{ @@ -225,57 +460,136 @@ Both these lines produce the same integer: \getbuffer \stoplines -When there is a fraction, the value is multiplied by 1000. - -So how should this be further integrated? If we drop design sizes at the file -definition level the whole font mechanism could be simplified a lot, but we cannot -do that. Another approach is to let users use the previously mentioned more low -level commands. A but of help can be provided with a command like - -\starttyping -\enableautoglyphscaling -\stoptyping - -which pays of when it is issues before \type {\starttext} and before a body fonts -gets defined because it does some overloading of defining commands. At the brink -of 2021 I'm not sure yet what is best. One reason is that a compatibility layer -is not really compatible because glyph scaling gives slightly different scaled in -practice (which relates to some old time accuracy hackery). This sounds worse -that it is because in practice scaling is done for sections heads and so, which -are less present and don't interfere with the running text. - -Let me stress once more: if you need this kind of scaling it pays off. If you -load multiple instances of large (e.g.\ \CJK) fonts, it makes sense too. But, for -instance on a document like the \LUAMETATEX\ manual it only saves 2 instances on -158, and those are the few bold fonts used for titling. - -That said, here is another example: +You can do strange things with these primitives but keep in mind that you can +also waste the defaults. -\startbuffer +\startbuffer[definition] \def\UnKernedTeX {T% {\glyph xoffset -.2ex yoffset -.4ex `E}% {\glyph xoffset -.4ex options "60 `X}} +\stopbuffer +\startbuffer[example] We use \UnKernedTeX\ and {\bf \UnKernedTeX} and {\bs \UnKernedTeX}: the slanted version could use some more left shifting of the E. \stopbuffer -\typebuffer +\typebuffer[definition,example] This gives is the \TEX\ logos (but of course we normally use the real ones instead). -\getbuffer +\startnarrower + \darkred \getbuffer[definition,example] +\stopnarrower + +Because offsets are (also) used for handling font features like mark and cursive +placement as well as special inter|-|character positioning, the above is +suboptimal. Here is a better alternative: + +\startbuffer[definition] +\def\UnKernedTeX + {T\glyph left .2ex raise -.4ex `E\glyph left .4ex `X\relax} +\stopbuffer + +\typebuffer[definition] + +The result is the same: + +\startnarrower + \darkgreen \getbuffer[definition,example] +\stopnarrower + +But anyway: don't over|-|do it. We could deal with such cases for decades without +these fancy new features. The next example show margins in action: + +\startlinecorrection +\bTABLE[align=middle,width=.33\textwidth] + \bTR + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph raise 3pt `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph raise -3pt `M}>\eTD + \eTR + \bTR[frame=off] + \bTD \tttf \eTD + \bTD \tttf raise 3pt \eTD + \bTD \tttf raise -3pt \eTD + \eTR + \bTR + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph left 3pt `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph right 2pt `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph left 3pt right 2pt `M}>\eTD + \eTR + \bTR[frame=off] + \bTD \tttf left 3pt \eTD + \bTD \tttf right 2pt\eTD + \bTD \tttf left 3pt right 2pt\eTD + \eTR + \bTR + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph left -3pt `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph right -2pt `M}>\eTD + \bTD \showglyphs \multiply\glyphscale by 2 <{\darkgray \glyph left -3pt right -2pt `M}>\eTD + \eTR + \bTR[frame=off] + \bTD \tttf left -3pt \eTD + \bTD \tttf right -2pt \eTD + \bTD \tttf left -3pt right -2pt \eTD + \eTR +\eTABLE +\stoplinecorrection + +Here is another way of looking at it: + +\startbuffer +\glyphscale 4000 +\vl\glyph `M\vl\quad +\vl\glyph raise .2em `M\vl\quad +\vl\glyph left .3em `M\vl\quad +\vl\glyph right .2em`M\vl\quad +\vl\glyph left -.2em right -.2em`M\vl\quad +\vl\glyph raise -.2em right .4em`M\vl +\stopbuffer + +\typebuffer + +The raise as well as left and right margins are taken into account when calculating the +dimensions of a glyph. + +{\getbuffer} + + +\stopsection + +\startsection[title={Implementation}] + +Discussing the implementation in the engine makes no sense here, also because +details might change. However, it is good to know that quite some properties +travel with the glyph nodes, for instance the scales and offsets. The dimensions +(width, height and depth) are not stored in the glyph node but calculated from +the font, scales and optionally the offsets and expansion factor. One problem is +that the more clever (and nice) solutions we cook up, the more it might impact +performance. So, I will delay some experiments till I have a more powerful +machine. + +One reason for {\em not} storing the dimensions in a glyph node is that we often +copy those nodes or change character fields in the font handler and we definitely +don't want the wrong dimensions there. At that moment, offsets and margin fields +don't reflect features yet, so copying them is no big deal. However, dimensions +are rather character bound so every time a character is set, we also would have +to set the dimensions. Even worse, when we can set them, the question arises if +they actually were already set explicitly. So, this is a can of worms we're not +going to open: the basic width, height and depth of the glyph as specified in the +font is used and combines with actual dimensions (likely already scaled according +the glyph scales) in offset and margin fields. + +Now, I have to admit that especially playing with using margins to glyphs instead +of font kerns is more of an experiment to see what the consequences are than a +necessity, but what would be the joy of \TEX\ without such experiments. And as +usual, in \CONTEXT\ these will become options in the font handler that one can +either or not enable. -After doing this with text, I wondered if we can avoid multiple sizes of an -otherwise same math font. Currently text, script and script script styles all use -the same font, but scaled. And, indeed, experiments show that this can be done, -although the math renderer had to be adapted to it. So, for now it's an -experiment. Users have to check if things are okay. Also, we have slightly -different rounding than with normal scaling. Of course the big advantage is that -we have less instances (math can add up more than text as every size has in fact -three instances). +\stopsection \stopchapter @@ -294,7 +608,7 @@ three instances). \starttext \startbuffer -\definescaledfont[bfe][xscale=2000,yscale=6000,style=bf] +\definetweakedfont[bfe][xscale=2000,yscale=6000,style=bf] \setuphead[chapter][style=\bfe] @@ -332,3 +646,8 @@ three instances). % anything) on YT. Both examples of where (imo extensive) practicing real % instruments can bring you with todays diverse equipment. These are interesting % times (it's now last days of 2020). +% +% The initial \definescaledfont was replaced by \definetweakedfont in the first +% week of Januari 2021, when I watched the joyful covers of Peter Gabriels +% "Steam" by Yoyoka which shows that the future belongs to the real young kids +% (so much explosive creativity!) and not to the old folks. diff --git a/doc/context/sources/general/manuals/followingup/followingup-style.tex b/doc/context/sources/general/manuals/followingup/followingup-style.tex index 68b52043c..51519f137 100644 --- a/doc/context/sources/general/manuals/followingup/followingup-style.tex +++ b/doc/context/sources/general/manuals/followingup/followingup-style.tex @@ -3,6 +3,8 @@ \startenvironment followingup-style +\enableexperiments[fonts.compact] % needed for font chapter + \usemodule[abbreviations-smallcaps] \logo [LUAMETATEX] {LuaMeta\TeXsuffix} diff --git a/doc/context/sources/general/manuals/luametatex/luametatex.tex b/doc/context/sources/general/manuals/luametatex/luametatex.tex index 588cc8952..1327ea3a1 100644 --- a/doc/context/sources/general/manuals/luametatex/luametatex.tex +++ b/doc/context/sources/general/manuals/luametatex/luametatex.tex @@ -79,7 +79,7 @@ % 290 pages, 9.5 sec, 149M lua, 35M tex, 30 instances \enableexperiments[fonts.compact] -\enabledirectives[fonts.injections.method=advance] +% \enabledirectives[fonts.injections.method=advance] % tricky ... not all xoffsets are advance robust \pushoverloadmode \unprotect % test code -- cgit v1.2.3