The path of an external Vector can be appended to the base path in real-time by making a reference to that vector here. The operation is completed immediately after the generation of the client vector's base path, prior to any transforms.

It is strongly recommended that the appended vector has its Visibility set to HIDDEN. Any direct transform that is applied to the vector will be utilised, but inherited transforms and placement information will be ignored.

If it is necessary for the two paths to flow from one to the other, set VF::JOIN_PATHS in the Flags field.

Note: Appended paths are not compliant with SVG and this feature is considered experimental.

The Child value refers to the first vector that forms a branch under this object. This field cannot be set directly as it is managed internally. Instead, use object ownership when a vector needs to be associated with a new parent.

The ClipRule attribute only applies to vector shapes when they are contained within a VectorClip object. In terms of outcome, the ClipRule works similarly to FillRule.

By default, vectors are rendered using the standard RGB colour space and alpha blending rules. Changing the colour space to LINEAR_RGB will tell the renderer to automatically convert sRGB values to linear RGB when blending on the fly.

The Cursor field declares the pointer's cursor image to display within the vector's boundary. The cursor will automatically switch to the specified image when it enters the boundary defined by the vector's path. This effect lasts until the cursor vacates the area.

It is a pre-requisite that the associated VectorScene has been linked to a Surface.

The DashArray is a list of lengths that alternate between dashes and gaps. If an odd number of values is provided, then the list of values is repeated to yield an even number of values. Thus 5,3,2 is equivalent to 5,3,2,5,3,2.

The DashOffset can be set in conjunction with the DashArray to shift the dash pattern to the left. If the offset is negative then the shift will be to the right.

The DisplayScale field will return the scale factor of the vector's path as it appears in the final rendering. For instance if the vector is the child of a viewport scaled down to 50%, the resulting value would be 0.5.

The EnableBkgd option must be set to true if a section of the vector tree uses filters that have BackgroundImage or BackgroundAlpha as a source. If it is not set, then filters using BackgroundImage and BackgroundAlpha references will not produce the expected behaviour.

The EnableBkgd option can be enabled on Vector sub-classes VectorGroup, VectorPattern and VectorViewport. All other sub-classes will ignore the option if used.

The painter used for filling a vector path can be defined through this field using SVG compatible formatting. The string is parsed through the ReadPainter() function. Please refer to it for further details on valid formatting.

It is possible to enable dual-fill painting via this field, whereby a second fill operation can follow the first by separating them with a semi-colon ; character. This feature makes it easy to use a common background fill and follow it with an independent foreground, alleviating the need for additional vector objects. Be aware that this feature is intended for programmed use-cases and is not SVG compliant.

Set the FillColour field to define a solid colour for filling the vector path. The colour is defined as an array of four 32-bit floating point values between 0 and 1.0. The array elements consist of Red, Green, Blue and Alpha values in that order.

If the Alpha component is set to zero then the FillColour will be ignored by the renderer.

The FillOpacity value is used by the painting algorithm when it is rendering a filled vector. It is multiplied with the Opacity to determine a final opacity value for the render.

The FillRule field indicates the algorithm which is to be used to determine what parts of the canvas are included when filling the shape. For a simple, non-intersecting path, it is intuitively clear what region lies "inside"; however, for a more complex path, such as a path that intersects itself or where one sub-path encloses another, the interpretation of "inside" is not so obvious.

This field assigns a graphics filter to the rendering pipeline of the vector. The filter must initially be created using the VectorFilter class and added to a VectorScene using VectorScene⇒AddDef(). The filter can then be referenced by ID in the Filter field of any vector object. Please refer to the VectorFilter class for further details on filter configuration.

The Filter value can be in the format ID or url(ID) according to client preference.

The ID field is provided for the purpose of SVG support. Where possible we would recommend that you use the existing object name and automatically assigned ID's for identifiers.

The InnerJoin value is used to make very technical adjustments to the way that paths are stroked when they form corners. Visually, the impact of this setting is only noticeable when a path forms an awkward corner that crosses over itself - usually due to the placement of bezier control points.

The available settings are MITER, ROUND, BEVEL, JAG and INHERIT. The default of MITER is recommended as it is the fastest, but ROUND produces the best results in ensuring that the stroked path is filled correctly. The most optimal approach is to use the default setting and switch to ROUND if issues are noted near the corners of the path.

LineCap is the equivalent of SVG's stroke-linecap attribute. It defines the shape to be used at the start and end of a stroked path.

LineJoin is the equivalent of SVG's stroke-linejoin attribute. It defines the shape to be used at path corners that are being stroked.

A mask can be applied to a vector by setting the Mask field with a reference to a VectorClip object. Please refer to the VectorClip class for further information.

All transforms that have been allocated via NewMatrix() can be read from the Matrices field. Each transform is represented by the VectorMatrix structure, and are linked in the order in which they are added to the vector.

When two line segments meet at a sharp angle and miter joins have been specified in LineJoin, it is possible for the miter to extend far beyond the thickness of the line stroking the path. The MiterLimit imposes a limit on the ratio of the miter length to the StrokeWidth. When the limit is exceeded, the join is converted from a miter to a bevel.

The ratio of miter length (distance between the outer tip and the inner corner of the miter) to StrokeWidth is directly related to the angle (theta) between the segments in user space by the formula: MiterLength / StrokeWidth = 1 / sin ( theta / 2 ).

For example, a miter limit of 1.414 converts miters to bevels for theta less than 90 degrees, a limit of 4.0 converts them for theta less than approximately 29 degrees, and a limit of 10.0 converts them for theta less than approximately 11.5 degrees.

If the Morph field is set to a Vector object that generates a path, the vector will be morphed to follow the target vector's path shape. This works particularly well for text and shapes that follow a horizontal path that is much wider than it is tall.

Squat shapes will fare poorly if morphed, so experimentation may be necessary to understand how the morph feature is best utilised.

The Next value refers to the next vector in the branch. If the value is NULL, the vector is positioned at the end of the branch.

The Next value can be set to another vector at any time, on the condition that both vectors share the same owner. If this is not true, change the current owner before setting the Next field. Changing the Next value will result in updates to the Parent and Prev fields.

This field assigns a numeric ID to a vector. Alternatively it can also reflect a case-sensitive hash of the ID field if that has been defined previously.

If NumericID is set by the client, then any value in ID will be immediately cleared.

The overall opacity of a vector can be defined here using a value between 0 and 1.0. The value will be multiplied with other opacity settings as required during rendering. For instance, when filling a vector the opacity will be calculated as FillOpacity * Opacity.

The Parent value will refer to the owner of the vector within its respective branch. To check if the vector is at the top or bottom of its branch, please refer to the Prev and Next fields.

Adjusting the render quality allows for fine adjustment of the paths produced by the rendering algorithms. Although the default option of AUTO is recommended, it is optimal to lower the rendering quality to CRISP if the path is composed of lines at 45 degree increments and FAST if points are aligned to whole numbers when rendered to a bitmap.

The PathTimestamp can be used as a basic means of recording the state of the vector's path, and checking that state for changes at a later time. For more active monitoring and response, clients should subscribe to the PATH_CHANGED event.

The Prev value refers to the previous vector in the branch. If the value is NULL, then the vector is positioned at the top of the branch.

The Prev value can be set to another vector at any time, on the condition that both vectors share the same owner. If this is not true, change the current owner before setting the Prev field. Changing the value will result in updates to the Parent and Next values.

Use ResizeEvent to receive feedback when the viewport that hosts the vector is resized. The function prototype is void callback(*VectorViewport, *Vector, DOUBLE X, DOUBLE Y, DOUBLE Width, DOUBLE Height, APTR Meta)

The dimension values refer to the current location and size of the viewport.

Note that this callback feature is provided for convenience. Only one subscription to the viewport is possible at any time. The conventional means for monitoring the size and position of any vector is to subscribe to the PATH_CHANGED event.

All vectors are required to be grouped within the hierarchy of a VectorScene. This requirement is enforced on initialisation and a reference to the top-level VectorScene is recorded in this field.

The Sequence is a string of points and instructions that define the path. It is based on the SVG standard for the path element d attribute, but also provides some additional features that are present in the vector engine. Commands are case insensitive.

The following commands are supported:

M: Move To
L: Line To
V: Vertical Line To
H: Horizontal Line To
Q: Quadratic Curve To
T: Quadratic Smooth Curve To
C: Curve To
S: Smooth Curve To
A: Arc
Z: Close Path

The use of lower case characters will indicate that the provided coordinates are relative (based on the coordinate of the previous command).

The stroker used for rendering a vector path can be defined through this field. The string is parsed through the ReadPainter() function in the Vector module. Please refer to it for further details on valid formatting.

This field defines the colour that will be used in stroking a path, and is comprised of floating point RGBA values. The intensity of each component is measured from 0 - 1.0. Stroking is disabled if the alpha value is 0.

This field is complemented by the StrokeOpacity and Stroke fields.

The StrokeOpacity value expresses the opacity of a path stroke as a value between 0 and 1.0. A value of zero would render the stroke invisible and the maximum value of one would render it opaque.

Please note that thinly stroked paths may not be able to appear as fully opaque in some cases due to anti-aliased rendering.

The StrokeWidth defines the pixel width of a path when it is stroked. The path will not be stroked if the value is zero. A percentage can be used to define the stroke width if it should be scaled to the size of the viewbox (along its diagonal). Note that this incurs a slight computational penalty when drawing.

The size of the stroke is also affected by scaling factors imposed by transforms and viewports.

If a vector maintains a keyboard subscription then it can define its priority within the tab order (the order in which vectors receive the focus when the user presses the tab key). The highest priority is 1, the lowest is 255 (the default). When two vectors share the same priority, preference is given to the older of the two objects.

A transition can be applied by setting this field with a reference to a VectorTransition object. Please refer to the VectorTransition class for further information.

Not all vector types are well-suited or adapted to the use of transitions. At the time of writing, only VectorText and VectorWave are able to take full advantage of this feature.