 |
|
|
|
 | |
|
|
|
|
 |
Log In | Not a Member? |
Contact ADC
|
|
||
Return to Index
The Instruction SetContents
IntroductionThis section presents an alphabetical listing of the TrueType instruction set. Each description begins with the basic facts. A brief description of the instruction's functionality follows. This material is intended for reference. For an introduction to the TrueType language see Instructing Fonts .
Understanding the instruction summariesThe following sections summarize the basic information needed to understand the instruction summaries that follow.
The instruction summary formatEach instruction description begins with a tabulation of basic information as shown in FIGURE 1 below. For a given instruction, only the relevant information fields are included. For example, the "From IS" field is omitted for all but the "push" instructions. In generial, if the "Uses" field is omitted from a particular instruction description, it is safe to assume that the instruction has no graphics state dependencies. The instruct control state variable is an exception to this rule. It will not appear in the uses field for each instruction though it can, turn off the execution of all instructions.FIGURE 1 The instruction summary format
Denoting stack interactionsIn the instruction summaries that follow, the arguments an instruction pops from the stack or pushes onto the stack will be listed along with a brief description of their purpose and data type.In the case of arguments popped from the stack, the first argument listed is the first
one popped from the stack, the second is the next one popped and so forth.
In the case of arguments popped from the stack, the first result pushed onto the stack appears
first, the second result pushed appears below it and so forth.
When it is necessary to summarize the stack interaction of an instruction, the information
will be written in a single line. The items popped are on the left to the left of two hyphens,
the items pushed are to the right. The example above would be written: ( arg1 arg2 arg3 -- result1 result2 ).
The right most item in the list is always the item at the top of the stack.
Data types used in the stackMany of the TrueType instructions interact with the interpreter stack. In simplest terms, they take data from the stack and return results to the stack. The stack elements that they manipulate are all 32 bit values. The way in which instructions interpret these values varies. Some consider all 32 bits pushed or popped to be significant. Some use only certain bits. Some treat the 32 bit quantity as a signed integer, some as an unsigned integer and some as a fixed point value.The data types that can appear on the stack are listed in Table 1 below. In cases where only a portion of the 32 bits pushed or popped are relevant, the data
type has a name that begins with a capital letter E for "extended." Unsigned values are extended to 32 bits with zeroes to the left of the bits that are significant. Signed values are sign extended to 32 bits. Fixed point numbers have names that begin with the letter F. The name consists of
the number of bits representing the integral part of the number, the letters "DOT", representing the
binary point. followed by the number of fractional bits. An extended
fixed point number begins with the letters EF. Generic stack elements have the data type StkElt. Any 32 bit quantity can have this data type. Table 1 : The instruction set data type
Understanding the illustrationsA number of instructions have accompanying illustrations. Most of these illustrations explain the effects an instruction has on the position of points in a glyph outline. FIGURE 1 lists the conventions used in those illustrations. Remember that,
For more information on moving points see Instructing Fonts . FIGURE 1 Key to illustrations
The Instructions
Pops one argument from the stack. This instruction is anachronistic and has no other effect.
Pops a 26.6 fixed point number, n, off the stack and pushes the absolute value of n onto the stack.
Pops two 26.6 fixed point numbers, n2 and n1, off the stack and pushes the sum of those two numbers onto the stack.
Aligns the two points whose numbers are the top two items on the stack along an axis orthogonal to the projection vector. Pops two point numbers, p2 and p1, from the stack and makes the distance between them zero
by moving both points along the freedom vector to the average of their projections along the
projection vector. In the illustration below, points p1 and p2 are moved along the freedom vector until the
projected distance between them is reduced to zero. The distance from A to B equals d/2 which
equals the distance from B to C. The value d/2 is one-half the original projected distance between
p1 and p2. ALIGNRP[] ALIGN to Reference Point
Aligns the points whose numbers are at the top of the stack with the point referenced by rp0. Pops point numbers, p1, p2, , ploopvalue, from the stack and aligns those points with the
current position of rp0 by moving each point pi so that the projected distance from pi to rp0
is reduced to zero. The number of points aligned depends up the current setting the state variable
loop. In the illustration below, point p is moved along the freedom vector until its projected
distance from rp0 is reduced to zero.
Takes the logical and of the top two stack elements. Pops the top two elements, e2 and e1, from the stack and pushes the result of a logical and of
the two elements onto the stack. Zero is pushed if either or both of the elements are FALSE (have
the value zero). One is pushed if both elements are TRUE
(have a non-zero value).
Calls the function identified by the number of the top of the stack. Pops a function identifier number, f, from the stack and calls the function identified by f.
The instructions contained in the function body will be executed. When execution
of the function is complete, the instruction pointer will move to the next location in
the instruction stream where execution of instructions will resume.
Takes the ceiling of the number at the top of the stack. Pops a number n from the stack and pushes n , the least integer value greater than or
equal to n. Note that the ceiling of n, though an integer value, is expressed as 26.6 fixed
point number. CINDEX[] Copy the INDEXed element to the top of the stack
Copies the indexed stack element to the top of the stack. Pops a stack element number, k, from the stack and pushes a copy of the kth stack element on
the top of the stack. Since it is a copy that is pushed, the kth element remains in its original
position. This feature is the key difference between the CINDEX[ ] and MINDEX[ ] instructions. A zero or negative value for k is an error.
Clears all elements from the stack.
Pops an integer from the stack. In non-debugging versions of the interpreter, the execution of instructions will continue. In debugging versions, available to font developers, an implementation dependent debugger will be invoked. This instruction is only for debugging purposes and should not be a part of a finished
font. Some implementations do not support this instruction.
Creates an exception to one or more CVT values, each at a specified point size and
by a specified amount. Pops an integer, n, followed by n pairs of exception specifications and control value table entry
numbers. DELTAC1[] changes the value in each CVT entry specified at the size and by the pixel amount
specified in its paired argument. The 8 bit arg component of the DELTAC1[] instruction decomposes into two parts. The most
significant 4 bits represent the relative number of pixels per em at which the exception is applied.
The least significant 4 bits represent the magnitude of the change to be made. The relative number of pixels per em is a function of the value specified in the argument and the
delta base. The DELTAC1[] instruction works at pixel per em sizes beginning with the delta base
through the delta_base + 15. To invoke an exception at a larger pixel per em size, use the DELTAC2[]
or DELTAC3[] instruction which can affect changes at sizes up to delta_base + 47 or, if necessary,
increase the value of the delta base. The magnitude of the move is specified, in a coded form, in the instruction. Table 5 lists the
mapping from exception values and the magnitude of the move made.The size of the step depends on the
value of the delta shift. Table 4: Magnitude values mapped to number of steps to move
For additional information on the DELTA instructions see Instructing Fonts .
Creates an exception to one or more CVT values, each at a specified point size and by a specified amount. Pops an integer, n, followed by n pairs of exception specifications and CVT entry numbers.
DELTAC2[] changes the value in each CVT entry specified at the size and by the amount specified
in its paired argument. The DELTAC2[] instruction is exactly the same as the DELTAC1[] instruction except
for operating at pixel per em sizes beginning with the (delta_base + 16) through the (delta_base + 31). To invoke an exception at a smaller pixel per em size, use the DELTAC1[] instruction. To invoke an exception at a smaller pixel per em size, use the DELTAC3[] instruction which can affect changes at sizes up to delta_base + 47 or, if necessary, change the value of the delta base. For more information see the entry for DELTAC1[] or Instructing Fonts .
Creates an exception to one or more CVT values, each at a specified point size and by a specified amount. Pops an integer, n, followed by n pairs of exception specifications and CVT entry numbers.
DELTAC3[] changes the value in each CVT entry specified at the size and by the amount specified
in its paired argument. The DELTAC3[] instruction is exactly the same as the DELTAC1 instruction except for operating
at pixel per em sizes beginning with the (delta_base + 32) through the
(delta_base + 47). For more information see the entry for DELTAC1[] or Instructing Fonts .
Creates an exception at one or more point locations, each at a specified point size and by a specified amount. DELTAP1[] works on the points in the zone reference by zp0. It moves the specified points at the
size and by the amount specified in the paired argument. Moving a point makes it possible to turn on
or off selected pixels in the bitmap that will be created
when the affected outline is scan converted. An arbitrary number of points and arguments can be
specified. The grouping [argi, pi] can be executed n times. The value of argi consists of a byte with lower
four bits of which represent the magnitude of the exception and the upper
four bits, the relative pixel per em value. The actual pixel per em size at which a DELTAP instruction works is a function of
the relative pixel per em size and the delta base. The DELTAP1[] instruction works at pixel per em
sizes beginning with the delta base through the delta_base + 15. To invoke an exception at a larger
pixel per em size, use the DELTAP2[] or DELTAP3[]
instruction which together can affect changes at sizes up to delta_base + 47 or, if necessary,
increase the value of the delta base. The magnitude of the move is specified, in a coded form, in the instruction. Table 5 lists the
mapping from exception values used in a DELTA instruction to the magnitude in steps of the move made. The size of the step depends on the value of
the delta shift. Table 5: Magnitude values mapped to number of steps to move
Creates an exception at one or more point locations, each at a specified point size and by a specified amount. DELTAP2[] works on the points in the zone reference by zp0. It moves the specified points at the
size and by the amount specified in the paired argument. Moving a point makes it possible to turn on
or off selected pixels in the bitmap that will be created
when the affected outline is scan converted. An arbitrary number of points and arguments can be
specified. The DELTAP2[] instruction is identical to the DELTAP1[] instruction save for operating at pixel
per em sizes beginning with the (delta_base + 16) through the (delta_base + 31). To invoke an
exception at a smaller pixel per em size, use the DELTAP1[] instruction. To invoke an exception
at a smaller pixel per em size, use the DELTAP3[] instruction. If necessary, change the value of
the delta_base.
Creates an exception at one or more point locations, each at a specified point size and by a specified amount. Pops an integer, n, followed by n pairs of exception specifications and points. DELTAP3[]
works on the points in the zone reference by zp0. It moves the specified points at the size and by
the amount specified in the paired argument. Moving a point makes it possible to turn on or off
selected pixels in the bitmap that will be created
when the affected outline is scan converted. An arbitrary number of points and arguments can be
specified. The DELTAP3[] instruction is identical to the DELTAP1[] instruction save for operating at pixel
per em sizes beginning with the (delta_base + 32) through the (delta base + 47). To invoke an
exception at a smaller pixel per em size, use the DELTAP1[] or the DELTAP2[] instruction. If
necessary, change the value of the delta base.
Pushes n, the number of elements currently in the stack, onto the stack.
Divides the number second from the top of the stack by the number at the top of the stack. Pops two 26.6 fixed point numbers, n1 and n2 off the stack and pushes onto the stack the quotient
obtained by dividing n2 by n1. The division takes place in the following fashion, n1 is shifted left
by six bits and then divided by 2. DUP[] DUPlicate top stack element
Duplicates the top element on the stack. Pops an element, e, from the stack, duplicates that element and pushes it twice.
Marks the end of an IF or IF-ELSE instruction sequence.
Marks the start of the sequence of instructions that are to be executed when an IF
instruction encounters a FALSE value on the stack. This sequence of instructions is
terminated with an EIF instruction. The ELSE portion of an IF-ELSE-EIF sequence is optional. ENDF[] END Function definition
Marks the end of a function definition or an instruction definition. Function definitions and instruction definitions cannot be nested.
Tests whether the top two numbers on the stack are equal in value. Pops two 32 bit values, e2 and e1, from the stack and compares them. If they are the same, one,
signifying TRUE is pushed onto the stack. If they are not equal, zero, signifying FALSE is placed
onto the stack.
Tests whether the number at the top of the stack, when rounded according to the round state, is even. Pops a 26.6 number, e, from the stack and rounds that number according to the current round state.
The number is then truncated to an integer. If the truncated number is even, one, signifying TRUE, is
pushed onto the stack; if it is odd, zero, signifying FALSE, is placed onto the stack.
Marks the start of a function definition and pops a number, f, from the stack to uniquely identify this function. That definition will terminate when an ENDF[] is encountered in the instruction stream. A function definition can appear only in the font program or the CVT program. Functions must be defined before they can be used with a CALL[ ] instruction. FLIPOFF[] set the auto FLIP Boolean to OFF
Sets the auto flip Boolean in the graphics state to FALSE causing the MIRP[] and MIAP[] instructions to use the sign of control value table entries. When auto flip is set to FALSE, the direction in which distances are measured becomes significant. The default value for the auto flip state variable is TRUE. FLIPON[] set the auto FLIP Boolean to ON
Sets the auto flip Boolean in the graphics state to TRUE causing the MIRP[] and MIAP[] instructions to ignore the sign of control value table entries. When the auto flip variable is TRUE, the direction in which distances are measured becomes insignificant. The default value for the auto flip state variable is TRUE.
Makes an on-curve point an off-curve point or an off-curve point an on-curve point. Pops points, p, p1, p2, , ploopvalue from the stack. If pi is an on-curve point it is made an
off-curve point. If pi is an off-curve point it is made an on-curve point. None of the points pi
is marked as touched. As a result, none of the flipped points will be affected by an IUP[ ]
instruction. A FLIPPT[ ] instruction redefines the shape of a glyph outline.
Changes all of the points in the range specified to off-curve points. Pops two numbers defining a range of points, the first a highpoint and the second a lowpoint.
On-curve points in this range will become off-curve points. The position of the points is not
affected and accordingly the points are not marked as touched.
Makes all the points in a specified range into on-curve points. Pops two numbers defining a range of points, the first a highpoint and the second a lowpoint.
Off-curve points in this range will become on-curve points. The position of the points is not
affected and accordingly the points are not marked as touched.
Takes the floor of the value at the top of the stack. Pops a 26.6 fixed point number n from the stack and returns n , the greatest integer value less
than or equal to n. Note that the floor of n, though an integer value, is expressed as 26.6 fixed
point number. GC[a] Get Coordinate projected onto the projection vector
Gets the coordinate value of the specified point using the current projection vector. Pops a point number p and pushes the coordinate value of that point on the current projection
vector onto the stack. The value returned by GC[] is dependent upon the current direction of the
projection vector. The illustration below, GC[1], with p1 at the top of the stack, returns the original position
of point p1 while GC[0], with p2 at the top of the stack, returns the current position of point
p2.
Used to obtain data about the version of the TrueType engine that is rendering the font as well as the characteristics of the current glyph. The instruction pops a selector used to determine the type of information desired and pushes a result onto the stack. Setting bit 0 in the selector requests the engine version. Setting bit 1 asks whether
the glyph has been rotated. Setting bit 2 asks whether the glyph has been stretched. To
request information on two or more of these values, set the appropriate bits. For
example, a selector value of 6 (0112) requests information on both rotation and stretching. The result is pushed onto the stack with the requested information. Bits 0 through 7 of result
comprise the font engine version number. The version numbers are listed in TABLE 0-2. Bit 8 is set to 1 if the current glyph has been rotated. It is 0 otherwise. Bit 9 is
set to 1 to indicate that the glyph has been stretched. It is 0 otherwise. TABLE 0-1 Selector bits and the results produced
The possible values for the engine version are given in TABLE 0-2. TABLE 0-2 Font engine version number
If the TrueType engine is the System 7.0 version and the selector requested information on the version number, rotation and stretching and the glyph is rotated but not stretched, the result will be 01 0000 00102 or 258.
Decomposes the current freedom vector into its x and y components and puts those components on the stack as two 2.14 numbers. The numbers occupy the least significant two bytes of each long. The first component pushed, px, is the x-component of the freedom vector. The second pushed, py, is the y-component of the freedom vector. Each is a 2.14 number. GFV[] treats the freedom vector as a unit vector originating at the grid origin. In the illustration below, the distance from point A to point B is 1 unit.
Decomposes the current projection vector into its x and y components and pushes those components onto the stack as two 2.14 numbers. The first component pushed, px, is the x-component of the projection vector. The second pushed, py, is the y-component of the projection vector. GPV[] treats the projection vector as a unit vector originating at the grid origin. In the
illustration below, the distance from point A to point B is one unit.
Compares the size of the top two stack elements. Pops two integers, e2 and e1, from the stack and compares them. If e1 is greater than e2, one,
signifying TRUE, is pushed onto the stack. If e1 is not greater than e1, zero, signifying FALSE,
is placed onto the stack.
Compares the size of the top two stack elements. Pops two integers, e2 and e1, from the stack and compares them. If e1 is greater than or equal
to e2, one, signifying TRUE, is pushed onto the stack. If e1 is not greater than or equal to e1,
zero, signifying FALSE, is placed onto the stack.
Begins the definition of an instruction. The instruction is identified by the opcode popped. The intent of the IDEF[ ] instruction is to allow old versions of the scaler to work with fonts that use instructions defined in later releases of the TrueType interpreter. Referencing an undefined opcode will have no effect. The IDEF[ ] is not intended for creating user defined instructions. The FDEF[ ] should be used for that purpose. The instruction definition that began with the IDEF[ ] terminates when an ENDF[ ]
is encountered in the instruction stream. Nested IDEFs are not allowed. Subsequent executions of the
opcode popped will be directed to the contents of this instruction definition. IDEFs should be
defined in the font program. Defining instructions in the CVT program is not recommended.
Marks the beginning of an if-statement. Pops an integer, e, from the stack. If e is zero (FALSE), the instruction pointer is moved to the
associated ELSE or EIF[] instruction in the instruction stream. If e is nonzero (TRUE), the next
instruction in the instruction stream is executed. Execution
continues until the associated ELSE[] instruction is encountered or the associated EIF[] instruction
ends the IF[] statement. If an associated ELSE[] statement is found before the EIF[], the instruction
pointer is moved to the EIF[] statement. INSTCTRL[ ] INSTRuction execution ConTRoL
Sets the instruction control state variable making it possible to turn on or off the
execution of instructions and to regulate use of parameters set in the CVT program. This instruction clears and sets various control flags. The selector is used to choose the
relevant flag. The value determines the new setting of that flag. In the version 1.0 there are only two flags in use. Flag 1 is used to inhibit grid-fitting. It is chosen with a selector value of 1. If
this flag is set to TRUE (v=1), any instructions associated with glyphs will not be executed.
If the flag is FALSE (v=0), instructions will be executed. For example, to inhibit grid-fitting when a glyph is being rotated or stretched, use the following sequence on
the preprogram:
Flag 2 is used to establish that any parameters set in the CVT program should be ignored when
instructions associated with glyphs are executed. These include, for
example, the values for scantype and the CVT cut-in. When flag2 is set to TRUE the
default values of those parameters will be used regardless of any changes that may
have been made in those values by the preprogram. When flag2 is set to FALSE, parameter values
changed by the CVT program will be used in glyph instructions. INSTCTRL[] can only be executed in the CVT program.
Interpolates the position of the specified points to preserve their original relationship with
the reference points rp1 and rp2. Pops point numbers, p1, p2, , ploopvalue, from the stack. Moves each point
pi so that its
relationship to rp1 and rp2 is the same as it was in the original uninstructed
outline. That is,
the following relationship holds:
This instruction is illegal if rp1 and rp2 occupy the same position on the
projection vector. More intuitively, an IP[] instruction preserves the relative relationship of a point relative to
two reference points. In the illustrations below, point p is interpolated relative to reference points rp1
and rp2. In the first illustration, which depicts the situation before the IP[]
instruction is executed, the distance from of point p to the original position of rp1 is
d1 and the distance from point p to the original position of point rp2 is
d2. The ratio of the two distances is d1:d2. ISECT[] moves point p to the InterSECTion of two lines
Moves the specified point to the intersection of the two lines specified. Pops the end points of line A, a0 and a1, followed by the end points of line
B, b0 and b1 followed by point p. Puts point p at the intersection of the lines
A and B. The points a0 and a1 define line A. Similarly, b0 and
b1 define line B. ISECT ignores the freedom vector in moving point p. In the degenerate case of parallel lines A and B, the point is put in the middle.
That is.
In the illustration below, point p is moved from its current position to the intersection of the
line defined by a0, a1 and the line defined by b0, b1.
Note that point p need not move along the freedom vector but is simply relocated at the point of
intersection.
IUP[a] Interpolate Untouched Points through the outline
Interpolates untouched points in the zone referenced by zp2 to preserve the original
relationship of the untouched points to the other points in that zone. Considers the reference glyph outline contour by contour, moving any untouched points that fall
sequentially between a pair of touched points. How such a point is moved, however, depends on whether
its projection fall between the projections of
the touched points. That is, if the projected x-coordinate or y-coordinate (depending on whether the
interpolation is in x or in y) of an untouched point were originally between those of the touched
pair, that coordiante is linearly interpolated between the new coordinates of the touched points.
Otherwise the untouched point is shifted by the amount the nearest touched point was shifted from
its original outline position. The value of the Boolean a, determines whether the interpolation will
be in the x-direction or the y-direction. The current settings of the freedom and projection vectors
are not relevant. The set of fiigures below illustrates this distinction. The first illustration shows the contour
before the IUP[] instruction is executed. Here p1, p2, p3,
p4 and p5 are consecutive points on a
contour. Point p2, p3 and p4 all fall sequentially between
p1 and p5 on the contour. Assume that
point p3 has been touched. Point p4 has an x-coordinate that is between p1 and p5 while
points p2 and p3 do not. Assume that p1 and p5 have been moved by a previous
instructions and that point p3 has been touched but not moved from its original position.
As a result of an IUP[1]
an interpolation in the x--direction takes place. Point p4 will be linearly interpolated.
Point p2 will be shifted by the amount the nearest touched point was shifted. Point
p3 will be unaffected. (Points p2 and p4 are assumed to be in their
original position. This is not strictly necessary as a point that has been moved can be untouched
with the UTP[ ] instruction and hence subject to the actions of an IUP[ ] instruction.) As the result of the IUP[1] instruction, two points are moved. The first move is the
shift illustrated below. Point p1 has moved a distance ds units parallel to the x-axis from its
original position. Point p2 is moved parallel to the x-axis until it is at a distance
equal to ds
from its original position. The second move is the linear interpolation shown in the illustration below. Point
p4 is moved along the specified axis to a new position that preserves its relative distance
from points p1 and p5. After the interpolation the ratio of the original
distance from point p4 to p1 (d1) to the original distance of point
p4 to p5 (d2) is the same as the ratio of the new distance from
point p4 to p1(d3) to the new distance of point p4 to
p4 (d4). That is: d1:d2 = d3:d4 This instruction operates on points in the glyph zone pointed to by zp2. This zone
should always be zone 1. Applying IUP[ ] to zone 0 is illegal. The IUP[ ] instruction does not touch the points it moves. Thus the untouched points
affected by an IUP[ ] instruction will be affected by subsequent IUP[] instructions
unless they are touched by an intervening instruction.
Moves the instruction pointer to a new location specified by the offset popped from the stack. Pops an integer offset from the stack. The signed offset is added to the instruction pointer and
execution is resumed at the new location in the instruction steam. The
jump is relative to the position of the instruction itself. That is, an offset of +1 causes the
instruction immediately following the JMPR[] instruction to be executed.
Moves the instruction pointer to a new location specified by the offset popped from the stack if
the element tested has a FALSE (zero) value. Pops a Boolean value, e and an offset. In the case where the Boolean, e, is FALSE, the signed
offset will be added to the instruction pointer and execution will be resumed at the new location;
otherwise, the jump is not taken. The jump is relative to the position
of the instruction itself.
Moves the instruction pointer to a new location specified by the offset value popped from the stack if the element tested has a TRUE value. Pops a Boolean value, e and an offset. If the Boolean is TRUE (non-zero) the signed offset will
be added to the instruction pointer and execution will be resumed at the address obtained. Otherwise,
the jump is not taken. The jump is relative to the position of the instruction itself. LOOPCALL[] LOOP and CALL function
Repeatedly calls a function. Pops a function number f and a count. Calls the function, f, count number of times.
Compares the two number at the top of the stack. The test succeeds if the second of
the two numbers is smaller than the first. Pops two integers from the stack, e2 and e1, and compares them. If
e1 is less than e2, 1, signifying TRUE, is pushed onto the stack. If
e1 is not less than e2, 0, signifying FALSE, is placed onto the stack.
Compares the two numbers at the top of the stack. The test succeeds if the second of the two numbers is smaller than or equal to the first. Pops two integers, e2 and e1 from the stack and compares them. If e1 is less than or
equal to e2, one, signifying TRUE, is pushed onto the stack. If e1 is greater
than e2, zero, signifying FALSE, is placed onto the stack. MAX[] MAXimum of top two stack elements
Returns the larger of the top two stack elements. Pops two elements, e2 and e1, from the stack and pushes the larger of these two
quantities onto the stack.
Uses zp0 with point p1, zp1 with point p2, projection vector, dual projectionv ector Measures the distance between the two points specified. Pops two point numbers p2 and p1 and measures the distance between the two
points specified. The distance, d, is pushed onto the stack as a pixel coordinate. The distance is
signed. Reversing
the order in which the points are listed will change the sign of the result. Depending upon the setting of the Boolean variable a, distance will be measured in the original
outline or the grid-fitted outline. MD[0] measures the distance in the original outline while MD[1]
measures the distance in the grid-fitted outline. As
always, distance is measured along the projection vector. Just as reversing the order
in which the points are listed will change the sign of the distance, reversing the orientation of
the projection vector will have the same effect. In the example below, MD[1] will yield the original outline distance from point p1 to point p2.
MD[0] will yield the distance from point p1 to point p2. MDAP[a] Move Direct Absolute Point
Touch and, in some cases, round the specified point. A point that is "dapped" will be unaffected by subsequent IUP[ ] instructions and is generally intended to serve as a reference point for future instructions. Dapping a point with rounding set to grid will cause the point to have an integer valued coordinate along the projection vector. If the projection vector is set to the x-axis or y-axis, this will cause the point to be grid-aligned. Pops a point number, p, and sets reference points rp0 and rp1 to point p. If the Boolean a
is set to 1, the coordinate of point p, as measured against the projection vector, will be rounded
and then moved the rounded distance from its current position.
If the Boolean a is set to 0, point p is not moved, but nonetheless is marked as touched in the
direction(s) specified by the current freedom vector. MDRP[abcde] Move Direct Relative Point
Preserves the master outline distance between the specified point and the reference point rp0. Pops a point number, p, and moves point p along the freedom vector so that the distance from its
new position to the current position of rp0 is the same as the distance between the two points in the
original uninstructed outline, and then adjusts it to
be consistent with the Boolean settings. Note that it is only the original positions
of rp0 and point p and the current position of rp0 that determine the new position of point p along
the freedom vector. MDRP[] is typically used to control the width or height of a glyph feature using a value which
comes from the original outline. Since MDRP[] uses a direct measurement and does not reference the
control value cut-in, it is used to control
measurements that are unique to the glyph being instructed. Where there is a need
to coordinate the control of a point with the treatment of points in other glyphs in
the font, a MIRP[] instruction is needed. Though MDRP[] does not refer to the CVT, its effect does depend upon the single-width cut-in value. If the device space distance between the measured value taken
from the uninstructed outline and the single width value is less than the single width
cut-in, the single width value will be used in preference to the outline distance.
In other words, if the two distances are sufficiently close (differ by less than the
single width cut-in), the single width value will be used. The setting of the round state graphics state variable will determine whether and
how the distance of point p from rp0 is rounded. If the round bit is not set, the value will be
unrounded. If the round bit is set, the effect will depend upon the choice of rounding state. A MDRP[] instruction can also be set to use the minimum distance value. Minimum distance sets a
lower bound on the value the distance between two points can be rounded to. Distances measured with the MDRP[] instruction, like all TrueType distances, must be either black,
white or grey. Indicating this value in Booleans de allows the interpreter to compensate for engine
characteristics as needed. The illustration below, point p is moved along the freedom vector from its current position to a
new position that is a distance, d from the reference point rp0. This distance is the same as the
original distance from p to rp0. MIAP[a] Move Indirect Absolute Point
Makes it possible to coordinate the location of a point with that of other similar
points by moving that point to a location specified in the control value table. Pops a CVT entry number n and a point number p and then moves point p to the absolute coordinate
position specified by the nth control value table entry. The coordinate is measured along the current
projection vector. If boolean a has the value one, the position will be rounded as specified by round
state. If boolean a has the value one and the device space difference between the CVT value and the
original position is greater than the control value cut-in, the original position will be rounded
(instead of the CVT value.) The a Boolean above controls both rounding and the use of the control value cut-in. To have this
Boolean specify only whether or not the MIAP[] instruction should look at the control value cut-in
value, use the ROFF[] instruction to turn off rounding. This instruction can be used to "create" twilight zone points. This is accomplished
by setting zp0 to zone 0 and moving the specified point, which is initially at the origin to the
desired location. In the illustration below, point p is moved along the freedom vector until it occupies a position
that projects to c units along the projection vector. MIN[] MINimum of top two stack elements
Returns the minimum of the top two stack elements. Pops two elements, e2 and e1, from the stack and pushes the smaller of these two quantities onto
the stack. MINDEX[] Move the INDEXed element to the top of the stack
Moves the indexed element to the top of the stack thereby removing it from its original position. Pops an integer, k, from the stack and moves the element with index k to the top of the stack. MIRP[abcde] Move Indirect Relative Point
Makes it possible to coordinate the distance between a point and a reference point with other similar distances by making that distance subject to a control value table entry. Moves point p along the freedom vector so that the distance from p to the current position of
rp0 is equal to the distance stated in the
referenced CVT entry, assuming that the cut-in test succeeds. Note that in making the cut-in test,
MIRP[] uses the
original outline distance between p and rp0. If the cut-in test fails, point p will be moved so
that its distance from the current position of rp0 is equal to the original outline distance between
p and the point referenced by rp0. A MIRP[] instruction makes it possible to preserve the distance between two points subject to a
number of qualifications. Depending upon the setting of Boolean flag
b, the distance can be kept greater than or equal to the value established by the minimum distance
state variable. Similarly, the instruction can be set to round the distance
according to the round state graphics state variable. The value of the minimum distance variable is
the smallest possible value the distance between two points can
be rounded to. Additionally, if the c Boolean is set, the MIRP[] instruction acts subject to the
control value cut-in. If the difference between the actual measurement and the
value in the CVT is sufficiently small (less than the cut-in value), the CVT value
will be used and not the actual value. If the device space difference between the CVT value and the
single width value is smaller than the single width cut-in, then use the single width value rather
than the control value table distance. The c Boolean above controls both rounding and the use of control value table entries.
If you would like the meaning of this Boolean to specify only whether or not the MIRP[] instruction
should look at the control value cut-in, use the ROFF[] instruction to turn off rounding. In this
manner, it is possible to specify that rounding is off but the cut-in still applies. MIRP[] can be used to create points in the twilight zone. In the illustration below, point p is moved along the freedom vector until its distance to point
rp0 is equal to the distance d found in the reference CVT entry.
Pushes the current number of pixels per em onto the stack. Pixels per em is a function of the
resolution of the rendering device and the current point size and the current
transformation matrix. This instruction looks at the projection vector and returns the number of
pixels per em in that direction. The number is always an integer. The illustration below shows magnifications of an 18 point Times New Roman s at 72 dpi, 144 dpi,
and 300 dpi, respectively. Increasing the number of pixels per em improves the quality of the image
obtained. It does not, however, change the absolute
size of the image obtained.
Pushes the current point size onto the stack. Measure point size can be used to obtain a value which serves as the basis for choosing whether
to branch to an alternative path through the instruction stream.
It makes it possible to treat point sizes below or above a certain threshold differently. The illustration below shows magnifications of 12 point, 24 point, and 48point Times New Roman Q
at 72 dpi. Note that increasing the point size of a glyph increases its
absolute size. On a low resolution device, like a screen, more detail can be captured
at a higher point size. MSIRP[a] Move Stack Indirect Relative Point
Makes it possible to coordinate the distance between a point and a reference point
by setting the distance from a value popped from the stack. Pops a distance, d and a point number, p, and makes the distance between point p and the current
position of rp0 equal to d. The distance, d, is in pixel coordinates. MSIRP[ ] is very similar to the MIRP[ ] instruction except for taking the distance
from the stack rather than the CVT. Since MSIRP[ ] does not use the CVT, the control value
cut-in is not a factor as it is in MIRP[ ]. Since MSIRP[ ] does not round, its effect
is not dependent upon the round state. MSIRP[] can be used to create points in the twilight zone. In the illustration below, point p is moved along the freedom vector until it is at a distance d
from rp0.
Multiplies the top two numbers on the stack. Pops two 26.6 numbers, n2 and n1, from the stack and pushes onto the stack the product of the two elements. The 52.12 result is shifted right by 6 bits and the high 26 bits are discarded yielding a 26.6 result. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
