Imagine 3.0 Object File Format

Rev 3.0 05-19-94 S.Kirvan
Copyright 1994 Impulse Inc., Mpls, MN 55444


        All information contained herein is subject to change without
        notice.  Knowledge is dangerous - use at your own risk.  No
        warranties are made or implied, and no liability or responsibility
        is assumed.     Good luck.


This text will describe Imagine 3.0's basic object file format. It is beyond the scope of this text to describe any of the file formats used for spline objects, deform tool, or any other object types not mentioned below. However, some of the data described below may apply to some of these undocumented object formats. It is also not the intent of this document to explain the implementation of the information contained in the TDDD files (ie. what equations we use to represent Imagine's paths - lighting models - forms geometry - tweening algorithms, etc.).


FORM TDDD is used by Impulse's Imagine 3.0 for 3D rendering data. TDDD stands for "3D data description". The files contain 3D object definitions, and can be extended to describe different types of object information.

The TDDD file is stored in Amiga (680x0) format, and conforms to the "IFF" file format on that computer. On IBM (80x86) based machines, much of the data refered to below will have to be byte reversed before it makes sense.

The IFF (interchange file format) format stores data in packets called "chunks." Each chunk begins with a long word identifier <ID> in ascii format. This identifier is immediately followed by a long word data-size. The data-size is measured in bytes and descrbes how much data, following the data-size long word, is part of the chunk identified by the <ID>. Imagine's IFF structure supports nesting of these chunks. For more info on the IFF standard, see the "Amiga ROM Kernal Reference Manual: Devices (3rd Edition)."

Currently, in "standard IFF" terms, a FORM TDDD has only one supported chunk type: an OBJ chunk describing the object heirarchy.

The OBJ chunk, in turn, is made up of smaller chunks with the standard IFF structure: <ID> <data-size> <data>.

The OBJ "sub-chunks" support object heirarchies. Currently, there are 2 types of supported OBJ sub-chunks: A DESC chunk, describing one node of a heirarchy; and a TOBJ chunk marking the end of a heirarchy chain. For each DESC chunk, there must be a corresponding TOBJ chunk.

In Imagine, the structure of the object heirarchy is as follows: Each heirarchy has a head (parent) object. The parent may have child objects. The children may have grandchildren, and so on. An object with children is a "grouped" object within Imagine.

Each object heirarchy is written in an OBJ chunk, along with all its descendants. The descendant heirarchy is supported as follows:

starting with the head (parent) object,

  1. A DESC chunk is written, describing the object.
  2. If the object in 1) has children, steps 1) thru 3) are performed for each child.
  3. A TOBJ chunk is written, marking the end of the object description.

The TOBJ sub-chunks have zero size -- and no data. The DESC sub-chunks are made up of "sub-sub-chunks", again, with the standard IFF structure: <ID> <data-size> <data>.

Reader software WILL FOLLOW the standard IFF procedure of skipping over any un-recognized chunks -- and "sub-chunks" or "sub-sub-chunks". The <data-size> field indicates how many bytes to skip. In addition it WILL OBSERVE the IFF rule that an odd <data-size> may appear, in which case the corredponding <data> field will be padded at the end with one extra byte to give it an even size.


First, there are several numerical fields appearing in the data, describing object positions, rotation angles, scaling factors, etc. They are stored as "32-bit fractional" numbers, such that the true number is the 32-bit number divided by 65536. So as an example, the number 3.14159 is stored as (hexadecimal) 0x0003243F (ie. 0x0003243F / 65536 = 3.14159). This allows the data to be independant of any particular floating point format. Numbers stored in this format are typedef'ed as "FRACT"s below.

Second, there are several color (or RGB) fields in the data. They are always stored as three UBYTEs representing the red, green and blue components of the color. Red is always first, followed by green, and then blue. For some of the data chunks, Imagine reads the color field into the 24 LSB's of a LONGword. In such cases, the 3 RGB bytes are preceded by a zero byte in the file.

The three basic data types that will be refered to herein are:

    BYTE        :  a single byte of data (char)
    WORD        :  a two byte data field (short)
    LONG        :  a four byte data field (long)

A "U" (ie. UBYTE) means unsigned.

The following "typedef"s are used below:

    typedef LONG    FRACT;                /* 4 bytes */
    typedef UBYTE   COLOR[3];             /* 3 bytes */

typedef struct vectors {

        FRACT X;          /* 4 bytes */
        FRACT Y;          /* 4 bytes */
        FRACT Z;          /* 4 bytes */
    } VECTOR;             /* 12 bytes total */

typedef struct matrices {

        VECTOR I;         /* 12 bytes */
        VECTOR J;         /* 12 bytes */
        VECTOR K;         /* 12 bytes */
    } MATRIX;             /* 36 bytes total */

typedef struct _tform {

        VECTOR r;         /* 12 bytes - position */
        VECTOR a;         /* 12 bytes - x axis */
        VECTOR b;         /* 12 bytes - y axis */
        VECTOR c;         /* 12 bytes - z axis */
        VECTOR s;         /* 12 bytes - size */
    } TFORM;              /*  60 bytes total */

typedef struct _pthd {

        TFORM   PData;    /* axis data */
        UWORD   inFrom;   /* previous axis number */
        UWORD   outTo;    /* next axis number */
        UWORD   flags;    /* flags for this axis */
                          /*   Bit 0 - reserved - zero for "Detail Editor" paths
                          /*   Bit 1 - an axis connects in to this axis
                          /*   Bit 2 - an axis connects out of this axis
                          /*   Bits 3 thru 15 - reserved
        UWORD   pad;      /* reserved */



NAME - size 18

BYTE Name[18]; ; a name for the object.

Object's name as it appears in the attributes requester. Used for tracking, etc.

SHP2 - size 4

    WORD    Shape;          ; number indicating object type
    WORD    Lamp;           ; bit field indicating lamp type

Valid shape numbers are:

        0 - Sphere
        2 - Axis            ; custom objects with points/faces
        5 - Ground
        1, 3, and 4 are reserved, and should never appear in TDDD files.

Perfect spheres have thier radius set by the X size parameter (see SIZE chunk). A ground object is an infinte plane perpendicular to the world Z axis. Its Z coordinate sets its height, and the X and Y coordinates are only relevant to the position of the "hot point" used in selecting the object in the editor (see POSI chunk). Custom objects have points, edges and triangles associated with them. Imagine's primative objects are cumstom (type 2) objects. The size fields are relevant only for drawing the object axes in the editor.

Lamp numbers are composed of several bit fields:

Bit 0 - Point light source.
Bit 1 - Parallel light source.
Bit 2 - Round shape.
Bit 3 - Rectangular shape.

Bit 4 - No Lens Flare FX flag.
Bit 5 - 1/R Diminishing intensity. Bit 6 - Controlled falloff.
Bit 7 - Cast Shadows.

Bits 8 to 14 - reserved.
Bit 15 - Bright object.

For a light casting object, bit 0 or 1 must be set - all other bits are optional. All lights emminate from the object's axes (see POSI, SIZE, and AXIS chunk) and shadow casting lights will be blocked by faces that have neither fog nor transparent attributes.

POSI - size 12

VECTOR Position; ; the object's position.

This is the position (in world coordinates) of the object's axes. Legal coordinates are in the range -32768 to 32767 and 65535/65536.

AXIS - size 36


These are direction vectors for the object coordinate system. They must be "orthogonal unit vectors" (ortho-normal) - i.e. the sum of the squares of the vector components must equal one (or close to it), and the vectors must be perpendicular.

SIZE - size 12

VECTOR Size; ; object size info

See SHAP chunk above. The sizes are used in a variety of ways depending on the object shape. For custom objects and lights, they are the lengths of the coordinate axes drawn in the editor.

BBOX - size 24

FRACT bounds[6]; ;bounding box data

The descriptions of the bounds array is as follows:

bounds[0] - negative X boundary (relative to object axis position) bounds[1] - negative Y boundary
bounds[2] - negative Z boundary
bounds[3] - posative X boundary
bounds[4] - posative Y boundary
bounds[5] - posative Z boundary

This chunk contains the objects bounding box info for use in improving redraw and loading speed when using Imagine's quick stage mode.

STND - variable size

The data in an STND chunk consists only of smaller sub-chunks. STID and STDT are the only types defined so far.

This is Imagine's state data chunk. There is a STND chunk for each (named) state in an object. Each STND chunk will contain a STID (state ID) chunk followed by one or several STDT (state data) chunks. (see STID and STDT chunks)

STID - size 20

    BYTE stid[18];      ; state name
    UWORD stFlags;      ; state flags
                        ;   Bit 0 - contains axis data (group)
                        ;   Bit 1 - contains shape data (points)
                        ;   Bit 2 - contains color/properties data
                        ;   Bits 3 thru 15 - reserved

This chunk contains the state name and a description of the type of data assiciated with this state. This chunk will only appear within a STND chunk and is usually followed by one or more STDT chunks.

STDT - variable size

    WORD tag;               ; state data type tags
                            ;   tag values are as follows:
                            ;   101 - contains object axis info
                            ;   102 - contains point (vertex) data
                            ;   103 - contains path data
                            ;   104 - contains axis size data
                            ;   105 - contains face color data (CLST)
                            ;   106 - contains face filter data (TLST)
                            ;   107 - contains face reflect data (RLST)
                            ;   108 - contains object attribute data
                            ;   all other values are reserved
    WORD flags;             ; state data flags

BYTE stateData[size]; ; state data - variable size

This is the state data chunk. The tag value describes what kind of information is actually stored within the stateData[] array. This chunk will only appear within a STND chunk and will be preceded by either a STID chunk or another STDT chunk. The stateData[] array is interpreted as follows depending upon the tag type:

        tag = 101 - contains object axis info - saved with grouping
            VECTOR axis_r;           ; axis position vector
            MATRIX axis_m;           ; axis alignment vectors
            (48 bytes total)

            See AXIS and POSI chunks.

        tag = 102 - contains point (vertex) data - saved with shape
            VECTOR obj_points[point_count];     ; object's points in 3 space
            (12 * point_count bytes total)

            point_count = point count for object - e.g. from PNTS chunk

        tag = 103 - contains path data - saved with shape
            PTHD pdata[ACount];        ; path data for object
            (68 * ACount bytes total)

            ACount = axis count for object - e.g. from PTH2 chunk

        tag = 104 - contains axis size data - saved with shape
            VECTOR size;            ; object size info
            (12 bytes total)

            See SIZE chunk.

        tag = 105 - contains face color data (CLST) - saved with properties
            COLOR   colors[face_count];          ; color values
            (face_count * 3 bytes total)

            face_count = face count for object - e.g. from FACE/CLST,...

        tag = 106 - contains face filter data (TLST) - saved with properties
            COLOR   filter[face_count];          ; filter values
            (face_count * 3 bytes total)

            face_count = face count for object

        tag = 107 - contains face reflect data (RLST) - saved with properties
            COLOR   reflect[face_count];          ; reflect values
            (face_count * 3 bytes total)

            face_count = face count for object

        tag = 108 - contains object attribute data - saved with properties
            UBYTE   props[8];           ; object properties (PRP1 chunk)
            UWORD   lamp;               ; bit field - lamp type (SHP2 chunk)
            UWORD   flags;              ; reserved
            VECTOR  intensity;          ; light intensity (INT1 chunk)
            FRACT   foglen;             ; value of foglength (FOGL chunk)
            UBYTE   color[4];           ; object color  (COLR chunk)
            UBYTE   reflect[4];         ; object reflectance (REFL chunk)
            UBYTE   filter[4];          ; object transparency (TRAN chunk)
            UBYTE   specular[4];        ; object specularity (SPC1 chunk)
            (44 bytes total)

            Note that the properties state does not save texture/brush info,
            only object base attributes.  See PRP1, SHP2, INT1, FOGL, COLR,
            REFL, TRAN, SPC1 chunks.

PNTS - size 2 + 12 * point count

    UWORD   PCount;                    ; point count
    VECTOR  Points[point_count];       ; points

This chunk has all the points for custom (type 2 - axis) objects. point_count is the total number of points on the object. Edges will refer to these points by thier position in the Points[] array (i.e. the point numbers appearing below run from 0 through point_count - 1).

EDGE - size 2 + 4 * edge_count

    UWORD   ECount;                   ; edge count
    UWORD   Edges[edge_count][2];     ; edges

This chunk contins the edge list for custom objects. The Edges[][2] array is pairs of point numbers that are connected by the edges. The values of Edges[n][0] and Edges[n][1] will thus be between 0 and point_count - 1, and the Points[] array will have to be refered to to find the endpoint positions of this edge. Faces will refer to these edges by thier position in the Edges[][] array (i.e. the edge numbers appearing below run from from 0 to edge_count - 1). (See PTNS chunk)

FACE - size 2 + 6 * face count

    UWORD   FCount;         ; face count
    UWORD   Faces[][3];     ; faces

This chunk contains the triangle (face) list for custom objects. The Faces[][3] array is triples of edge numbers that are connected to form triangles. This back references through the Edge list and then through the Point list to find the 3 space coordinates of the face's vertexes. (See EDGE and PNTS chunks) Note: it is possible that the edge numbers given for a face would use more than 3 point numbers all together ... this should be considered as an error ... however, Imagine doesn't enforce the desired constsistency when objects are loaded. This can lead to some confusion when testing "first time" code, since Imagine sometimes uses only the first two edge numbers, assumeing that the 3rd edge is constsient with the 1st two.

PTH2 - size 2 + 68 * axis count

UWORD ACount; ; axis count PTHD PData[ACount]; ; path (axis) data

This chunk contains the axis data for Imagine "path" objects. ACount is the number of axes in the path object. The PData array contains a bit of data for each point (axis) along the path. A closed path is made by setting the value of the inFrom[] variable of the first axis to the number of the last axis, and setting the outTo[] variable of the last axis to the number of the first axis (1). An open path will have to have the flags[] bits 1 (or 2) clear, showing that the first (or last) axis is only connected on one side ... the 1st axis should show a "connected out" flag, and the last axis should show a "connected in" flag only.

COLR - size 4
REFL - size 4
TRAN - size 4
SPC1 - size 4

    BYTE    pad;            ; pad byte - must be zero
    COLOR   col;            ; RGB color

These are the main object RGB color, and reflection, transmission and specularity coefficients.

CLST - size 2 + 3 * face_count
RLST - size 2 + 3 * face_count
TLST - size 2 + 3 * face_count

    UWORD   face_count;                  ; number of faces
    COLOR   colors[face_count];          ; colors

These are the color, reflection and transmission coefficients for each face in custom (type 2 - axis) objects. The face_count has to match the face count in the FACE chunk. The ordering corresponds to the face order. When the objects main attributes are altered, the new color values are copied into the whole colors[] array. Modifying color values in face mode or choosing "randomize colors" from the attributes requester will independantly alter the values in the colors[][] array. This chunk appears in all custom (type 2 - axis) objects.

TXT3 - variable size

    UWORD   Flags;          ; texture flags:
                            ;     Bit  0         - apply to child objs
                ;     Bits 1 thru 15 - reserved
    TFORM   TForm;          ; local coordinates of texture axes.
    FRACT   Params[16];     ; texture parameters
    UBYTE   PFlags[16];     ; parameter flags for texture requester
                            ;   Bit 0 - alter red color in color chip
                            ;   Bit 1 - alter green color in color chip
                            ;   Bit 2 - alter blue color in color chip
                            ;   Bit 3 - alter parameter when resizing object
                            ;   Bits 4 thru 7 - reserved
    BYTE    SubGr[18];      ; Subrgoup to restrict texture to
    BYTE    LockState[18];  ; State name for "texture tacking"
    UBYTE   Length;         ; length of texture file name

UBYTE Name[Length]; ; texture file name (not NULL terminated) UBYTE optionalpad; ; appears only if the name string has an even

                            ; length -- so the total length of the name
                ; "block" (length + name + pad?) comes out even

This chunk contains the texture data necessary for the renderer to communicate with Imagine's procedural texture modules and for positioning textures on objects. Subgr[], if used, restricts the texture application to the named subgroup. LockState[], if used, will lock (tack) the texture to the object's faces for object morphing without texture sliding. The values in Params[] are tweened (interpolated) internally by Imagine when morphing/animating textures. A TXT3 chunk appears for each texture applied to an object.

BRS4 - variable size

    UWORD   Flags;          ; brush type:
                            ;    0 - Color
                            ;    1 - Reflectivity
                            ;    2 - Filter
                            ;    3 - Altitude
                            ;    4 - Reflection
    UWORD   WFlags;         ; brush wrapping flags:
                            ;    Bit 0 - wrap x
                            ;    Bit 1 - wrap z
                            ;    Bit 2 - apply to children
                            ;    Bit 3 - repeat brush
                            ;    Bit 4 - mirror with repeats
                            ;    Bit 5 - inverse video
                            ;    Bit 6 - Use genlock
    TFORM   TForm;          ; local coordinates of brush axes.
    UWORD   FullScale;      ; full scale value
    UWORD   MaxSeq;         ; highest number for sequenced brushes
    BYTE    SubGr[18];      ; Subrgoup to restrict brush to
    BYTE    LockState[18];  ; Brush lockstate
    UBYTE   Length;         ; length of brush file name
    UBYTE   Name[Length];   ; brush file name (not NULL terminated)
    UBYTE   optionalpad     ; if name has even length (see TXT3 description)

This chunk contains the brush data necessary for the renderer to load and position brush maps (texture maps) on objects. FullScale is used to map the highest color value within a brush map to full-scale 255 for Imagine's internal interpritation of the brush. Subgr[], if used, restricts the brush application to the named subgroup. LockState[], if used, will lock (tack) the brush to the object's faces for object morphing without texture sliding. The value in MaxSeq is tweened (interpolated) internally, from 1 to MaxSeq, by Imagine when animating brushes - this way, brush morphing can be accomplished. A BRS4 chunk appears for each brush map applied to an object.

FOGL - size 4

FRACT foglen; ; value of foglength attribute

This is the object foglength set in Imagine's attributes requester.

PRP1 - size 8

UBYTE IProps[8]; ; more object properties

The discriptions of the IProps array is as follows:

IProps[0] - dithering factor (0-255) IProps[1] - hardness factor (0-255) IProps[2] - roughness factor (0-255) IProps[3] - shinyness factor (0-255) IProps[4] - index of refraction - ir = (float)IProps[4] / 100.0 + 1.0; IProps[5] - quickdraw type: 0=none, 1=bounding box, 2=quick edges IProps[6] - flag - Phong shading on/off IProps[7] - flag - Genlock on/off

The dithering factor controls the amount of color dithering used on the object - 255 is fully dithered. The hardness factor controls how tight the specular spot should be - 0 is a big soft spot, 255 is a tight hot spot The roughness factor controls how rough the object should appear

INT1 - size 12

VECTOR Intensity; ; light intensity

This has seperate R, G & B intensities for the light objects. Note that these color values are stored as FRACT's and are not limited to the 0 to 255 range of the usual UBYTE color values so lights can be brighter than 255 255 255.

ANID - size 64

    LONG    Cellno;         ; cell number ("key" cell)
    TFORM   TForm;          ; object position/axes/size in that cell.

For Imagine's "Cycle" objects, within EACH DESC chunk in the file - that is, for each object of the group, there will be a series of ANID chunks. The cell number sequences of each part of the group must agree with the sequence for the head object, and the first cell number must be zero.

FOR2 - size 56 + 12 * PC + 2 * keys

    WORD    NumC;               ; number of cross section points
    WORD    NumF;               ; number of slices
    WORD    Flags;              ; forms object type flag
                                ;   Bit 0 - X-Y Cross Section
                                ;   Bit 1 - One Former View
                                ;   Bit 2 - One Spacer View
                                ;   Bits 3 thru 15 - reserved
                                ;   (bit 0 off means Y-Z Cross Section)
                                ;   (bits 1 and 2 off means Two Former Views)
    WORD    keys;               ; number of defined key sections
    MATRIX  TForm;              ; object rotation/scaling transformation
    VECTOR  Shift;              ; object translation
    VECTOR  Points[PC];         ; "Forms" editor points
    WORD    sexions[keys];      ; list of key sections by number

For Imagine's "Forms" objects, the "PNTS" chunk above is not written out, but this structure is written instead. The object's real points are then calculated from these using a proprietary algorithm. The tranformation parameters above allow the axes of the real object be moved around relative to the "Forms" points. The value, PC, is calculated as follows:

        for Two Former Views:
            PC = keys * NumC + 4 * NumF;

        for One Former View:
            PC = keys * NumC + 2 * NumF;

        for One Spacer View:
            PC = keys * NumC + 1 * NumF;

PART - size 6

    WORD type;          ; tells what type of particles to use
                        ;   bits 0-3:  shape
                        ;       0x0000 - faces (no particles)
                        ;       0x0001 - tetrahedrons
                        ;       0x0002 - pyramids
                        ;       0x0003 - octahedrons
                        ;       0x0004 - cubes
                        ;       0x0005 - blocks
                        ;       0x0006 - dodecahedrons
                        ;       0x0007 - spheres
                        ;       0x0008 - random
                        ;       0x0009 - use object file
                        ;   bits 4-7:  centering
                        ;       0x0000 - inscribed
                        ;       0x0010 - circumscribed
                        ;       0x0020 - interpolated
                        ;       0x0030 - barycentric
                        ;   bits 8-11:  size
                        ;       0x0000 - small
                        ;       0x0100 - large
                        ;       0x0200 - random
                        ;       0x0300 - specify
                        ;   bits 12-15:  alignment
                        ;       0x0000 - to object
                        ;       0x1000 - to face
                        ;       0x2000 - random
    FRACT size;         ; used with specify size

This is the main object particalization parameters. This chunk describes the geometry of the particles to be used in place of the objects faces. The PTFN chunk contains the file name of the "use object file" type of particles, and the FGR2 chunk contains the particle geometry info for specific sub groups. Particles only work on custom (type 2 - axis) objects with faces. (see PTFN and FGR2 chunks)

PTFN - variable size

BYTE length; ; number of characters in the file name BYTE PartFileName[length]; ; particle file name (not null terminated)

    BYTE optionalpad;            ; appears only if name has an even length
                                 ; (see TXT3 description)

For Imagine's particalized objects. This is the filename for the "use object file" type of particlization. (see PART chunk)

FGR2 - variable size

    UWORD faceCount;            ; the number of faces in this subgroup
    BYTE  subGrName[18];        ; the name of the subgroup
    UWORD faceNums[faceCount];  ; the list of faces in this subgroup
    UWORD pType;                ; subgroup particle type - see PART chunk
    FRACT pSize;                ; subgroup particle size - see PART chunk
    UBYTE pFNSize;              ; character count in the particle file name
    BYTE  pFName[pFNSize];      ; particle filename - see PTFN chunk
    BYTE  optionalpad;          ; appears only if name has an even length

This is the Subgroup info for Imagine's custom (type 2 - axis) objects which have subgroups - the mnemonic, FGR2, stands for face group. pType, pSize, pFNSize, and pFName all deal with particalized subgroups. The faceNums[] array is a list of faces by numerical position in the face list as described in the FACE chunk. Valid face numbers run from zero through object_face_count - 1.

BBSG - size 18

BYTE bbsg[18]; ; big bone subgroup name

This is the Big Bone SubGroup name used with the bones function in Imagine. By design, BBSG will appear in the DESC chunk of a particular bone (usually an axis), and will refer to a subgroup name in a FGR2 chunk of the parent object of this entire group. (note: the "Bones" functions also assume that a state named DEFAULT appears in the state list of the group's parent object, containing at least "shape" and "grouping" data) (also, see SBSG chunk below)

SBSG - size 18

BYTE sbsg[18]; ; small bone subgroup name

This is the Small Bone SubGroup name used with the bones function in Imagine. By design, SBSG will appear in the DESC chunk of a particular bone (usually an axis), and will refer to a subgroup name in a FGR2 chunk of the parent of this entire group. (see BBSG chunk above)

EFLG - 2 + edge_count

    WORD    edge_count;                 ; the number of edges on the object
    UBYTE   edgeFlag[edge_count];       ; array of edge flags for each edge
                                        ;   Bits 0 thru 5 - reserved
                                        ;   Bit 6 - quick edge
                                        ;   Bit 7 - sharp edge

This chunk contains the flag values for all the edges of custom (type 2 - axis) objects with edges. These flags currently support the quick edge and sharp edge flags. (Note: Imagine writes this chunk only if one or more edges in the object actually has bit 6 or 7 set)

DESC notes

Again, most of these fields are optional, and some defaults are supplied. However, if there is a FACE chunk, there must also be a CLST chunk, an RLST chunk and a TLST chunk -- all with matching "count" fields. The SHAP chunk is not optional.

Your best bet in understanding the relationship between chunks (what's required, and what's not) will probably be through creating objects within Imagine, saving them out, and then interrogating and comparing the TDDD files.

The order in which the chunks appear is somewhat irrelevant. Some of the chunks contain a point count, or something similar, and some of them (STDT chunks) don't actually contain a count, but are based on a count. Imagine assigns the appropriate count based on the first occurence of a chunk whose size would depend on the count, and then enforces consitency as succeding chunks are processed.

For TXT3 and BRS4 (texture and brush) chunks, the order in which the chunks appear in the file determines the order they are listed in Imagine, and also the order in which they are applied during rendering.

For Imagine's "Quick Stage" mode, the DESC chunks are processed only until a certain minimum amount of data has been read in, and then it skips to the end of the DESC chunk. The "required" fields (in order to skip to the end) are NAME,POSN,ALGN,SIZE,SHP2 and BBOX. If state data (i.e. Bones data) is required from the object for stage animation, then it must appear before at least one of the "required" fields listed above, or it will be ignored -- similarly for cycle editor data (ANID chunks), and path (PTH2) data. For example, Imagine does the following: 1) writes all of the "required" chunks listed above except for the BBOX chunk, 2) writes ANID chunks (if any), 3) writes STND chunks (if any), 4) writes a PTH2 chunk (if reqd), 5) writes a BBOX chunk, and finally, 6) writes the rest of the data.

Unfortunately, Impulse does not have the support staff available to answer technical questions about the information included in this document. Hopefully, this will be a good starting point. How far you get with it will, most likely, be dependent upon hard work and perseverance.

Good Luck and Enjoy.

PC (80x86 CPU) notes

The IFF file format originated on machines in which the byte order for LONG (4 byte) and WORD (2 byte) data is "most significant byte first". This concept has been preserved in the "PC" versions of Imagine.

What it means, is that if you are writing code for the "other" type of CPU (80386 code, for example), you will need to reverse the byte ordering in (U)LONG, FRACT, and (U)WORD data wherever it appears (e.g. the FRACTs in a VECTOR structure must be (separatly) byte reversed ... the size field following a chunk identifier is another good example)

IFF file format notes

In case you are unfamiliar with the IFF file structure, the TDDD files have the following (simple, "single FORM") IFF structure:

form_ID           4 characters:  'F','O','R','M'
form_size         LONG size   : -- MSB(yte) first
form_type         4 characters:  'T','D','D','D'
    chunk_ID      4 characters: e.g. 'O','B','J',' '

chunk_size LONG size : -- byte reversed if appropriate chunk_data 'size' bytes:
chunk_pad 0 or 1 bytes: -- pad to even length if 'size' is odd

Note: The "form_size" field appearing after the "form_ID" is the total length of the data that FOLLOWS it, INCLUDING the 4-byte (TDDD) id. Also the "chunk_size" fields list the size of the data in the "chunk_data" blocks that follow. In other words, the size fields when rounded up to an even number, always list the number of bytes (after the size field) to skip forward in the file if, based on the ID field preceding the size, the reader can not or does not wish to interpret the data ... so, in particular, the sizes that appear DO NOT include the length of the ID and size fields themselves, and the 'form_size' DOES include 4 bytes for the 'form_type' field that follows it.

Imagine uses "extended sub-chunks" -- where for some chunk types, the data actually consists of a series of smaller chunks, in the same IFF form: ID/Size/Data/pad_byte_if_neccesary. In fact, the only "true" IFF chunk that imagine recognizes is the 'OBJ ' chunk -- which contains the complete data for a single heirarchy (group) of objects. Things are as they are, mainly for historical reasons ... once upon a time, TDDD files were also used to hold all the data for a single frame in an animation, and several 'OBJ ' chunks could appear, as well as more chunks giving data about the camera position, etc. Now, when Imagine writes a TDDD file, it contains only a single 'OBJ ' chunk. Imagine will still process a file containing multiple 'OBJ ' chunks, but in all cases, except when it loads a file into its "Detail Editor", it ignores all but the first object heirarchy.