# geometry

## Appendix B — History of the SSWF reference

### Dec 2, 2009

Moved the monolithic documentation to a multi-page hierarchical document that includes everything we had before plus many links, many terms attached to all pages (tags, English words.) And revision of most of the text for better English and clarification in some places.

Strengthen the formatting with CCK fields so all declarations look alike.

Broken up the actions from one large table to a set of pages.

### Dec 14, 2008

Started work on the Load() feature of the SSWF library. This helped fixing several small mistakes in the documentation.

Fixed the ...

## Appendix A — The geometry in SWF — Images

When appropriate, images can also be included in SWF files. All the images can be full color and also have an alpha channel.

## Appendix A — The geometry in SWF — Gradient Fills

It is possible in SWF to use gradient fills. The gradient definitions are pretty raw and require you to draw large objects (that you can scale down later if you wish). A radial fill will usually be used to draw a round corner or a big & smooth dot. A linear fill can be used to draw objects which go from one color to another. The linear fill goes from left to right by default. It can be rotation as required though. Yet, in either case what is drawn in the shape object needs to be at the right scale and in the right direction. This may not always prove easy to deal with!

## Appendix A — The geometry in SWF — Edges

Edges are used to define a shape vector based and also coordinates where images need to be drawn. The edges are always coordinates from where ever your last point was to where ever you want the next point to be (a little like a turtle in LOGO).

## Appendix A — The geometry in SWF — Matrix

The coordinates are often transformed with the use of a matrix. The matrix is similar to a transformation matrix in Postscript. It includes a set of scaling factors, rotation angles and translations.

When only the scaling factors are used (no rotation) then these are ratios as one would expect. If a rotation is also applied, then the scaling ratios will be affected accordingly.

## Appendix A — The geometry in SWF — Coordinates

The most common and simple geometric information are the object coordinates on the output screen. These are defined in TWIPs. There are 20 twips per pixels. Note that an embedded SWF file can be enlarged and/or reduced thus changing this basic scaling factor. To have exactly 20 twips per pixel you must ensure that the EMBED and/or OBJECT tags use a WIDTH and HEIGHT with exactly the same value as in the rectangle defined in the SWF header file divided by 20.

## Appendix A — The geometry in SWF

This appendix describes different aspects of the geometry in Flash. Note that some of the description uses 3D matrices. It is rather easy to simplify them and use just and only 2D matrices. The simplifications can usually be such that only 2 or 3 operations are required to get the proper coordinates used to render objects.

Remember that Flash uses TWIPs and thus you certainly will want to use floating points to make it easy on you.

## SWF Any Filter (swf_any_filter)

SWF Structure Info
Tag Flash Version:
8
SWF Structure:
```/* the filter type */
struct swf_filter_type {
unsigned char	f_type;
};

struct swf_filter_glow {
swf_filter_type	f_type;		/* 0, 2, 3, 4 or 7 */
unsigned char		f_count;
}
else {
f_count = 1;
}
swf_rgba		f_rgba[f_count];
if(f_type == Bevel) {
swf_rgba		f_highlight_rgba[f_count];
}
unsigned char		f_position[f_count];
}
signed long fixed	f_blur_horizontal;
signed long fixed	f_blur_vertical;
if(f_type != Glow) {
signed long fixed	f_distance;
}
signed short fixed	f_strength;
unsigned		f_knock_out : 1;
unsigned		f_composite_source : 1;
if(f_type == Bevel) {
unsigned		f_on_top : 1;
}
else {
unsigned		f_reserved : 1;
}
unsigned		f_passes : 4;
}
else {
unsigned		f_reserved : 4;
}
};

struct swf_filter_blur {
swf_filter_type		f_type;	/* 1 */
unsigned long fixed	f_blur_horizontal;
unsigned long fixed	f_blur_vertical;
unsigned		f_passes : 5;
unsigned		f_reserved : 3;
};

struct swf_filter_convolution {
swf_filter_type	f_type;		/* 5 */
unsigned char	f_columns;
unsigned char	f_rows;
long float	f_divisor;
long float	f_bias;
long float	f_weights[f_columns × f_rows];
swf_rgba	f_default_color;
unsigned	f_reserved : 6;
unsigned	f_clamp : 1;
unsigned	f_preserve_alpha : 1;
};

struct swf_filter_colormatrix {
swf_filter_type	f_type;		/* 6 */
long float	f_matrix[20];
};

struct swf_any_filter {
swf_filter_type			f_fitler_type;
swf_filter_blur			f_filter_blur;
swf_filter_colormatrix		f_filter_colormatrix;
swf_filter_convolution		f_filter_convolution;
swf_filter_glow			f_filter_glow;
};
```

A filter defines how to transform the objects it is attached to. The first byte is the filter type. The data following depend on the type. Because each filter is much different, they are defined in separate structures. You can attach a filter to an object using an ActionScript or the PlaceObject3 tag.

The following describes the different filters available since version 8.

...
Value Name Version

## SWF Shape Record (swf_shape_record)

SWF Structure Info
Tag Flash Version:
1
SWF Structure:
```/* if f_shape_record_type = 0 & f_end_of_shape = 0  then that's the end of the list of shape records */
struct swf_shape_record_end {
unsigned		f_shape_record_type : 1;
unsigned		f_end_of_shape : 5;
};
/* f_shape_record_type = 0 & at least one of the following five bits is not zero  then change style, fill and position setup */
struct swf_shape_record_setup {
unsigned		f_shape_record_type : 1;
if(f_tag == DefineShape) {1
unsigned	f_shape_reserved : 1;		/* always zero */
}
else {
unsigned	f_shape_has_new_styles : 1;
}
unsigned		f_shape_has_line_style : 1;
unsigned		f_shape_has_fill_style1 : 1;
unsigned		f_shape_has_fill_style0 : 1;
unsigned		f_shape_has_move_to : 1;
if(f_shape_has_move_to) {
unsigned	f_shape_move_size : 5;
signed twips	f_shape_move_x : f_shape_move_size;
signed twips	f_shape_move_y : f_shape_move_size;
}
if(f_shape_has_fill_style0) {
unsigned	f_shape_fill_style0 : f_fill_bits_count;
}
if(f_shape_has_fill_style1) {
unsigned	f_shape_fill_style1 : f_fill_bits_count;
}
if(f_shape_has_line_style) {
unsigned	f_shape_line_style : f_line_bits_count;
}
if(f_shape_has_new_styles) {
swf_styles	f_styles;
}
};

/* f_shape_record_type = 1 -- edge record */
struct swf_shape_record_edge {
unsigned		f_shape_record_type : 1;
unsigned		f_shape_edge_type : 1;
unsigned		f_shape_coord_size : 4;
f_shape_coord_real_size = f_shape_coord_size + 2;
if(f_shape_edge_type == 0) {
signed twips	f_shape_control_delta_x : f_shape_coord_real_size;
signed twips	f_shape_control_delta_y : f_shape_coord_real_size;
signed twips	f_shape_anchor_delta_x : f_shape_coord_real_size;
signed twips	f_shape_anchor_delta_y : f_shape_coord_real_size;
}
else {
unsigned	f_shape_line_has_x_and_y : 1;
if(f_shape_line_has_x_and_y == 1) {
signed twips	f_shape_delta_x : f_shape_coord_real_size;
signed twips	f_shape_delta_y : f_shape_coord_real_size;
}
else {
unsigned	f_shape_line_has_x_or_y : 1;
if(f_shape_line_has_x_or_y == 0) {
signed twips	f_shape_delta_x : f_shape_coord_real_size;
}
else {
signed twips	f_shape_delta_y : f_shape_coord_real_size;
}
}
}
};

union swf_shape_record {
swf_shape_record_end	f_shape_end;
swf_shape_record_setup	f_shape_setup;
swf_shape_record_edge	f_shape_edge;
};
```
• 1. From my tests with the official Macromedia Flash plugin, it looks that there is always a bit at this position. It seems however that it cannot be set to 1 in v1.0 of the tag (i.e. when the DefineShape tag is used).

The shape records are typed. Depending on that type, the contents vary. The following defines one structure for each type. The shape record is a union of these structures.

It is important to note that the f_shape_move_x and f_shape_move_y are not deltas from the current point, but a position from the current shape origin. All the other positions are defined as deltas from the previous position, including the anchors which are deltas from the control point position!