---

tr_types.h

#ifdef _MSC_VER
#pragma warning (disable:4786)
#endif

#include <vector>

typedef signed char bit8;
typedef unsigned char bitu8;
typedef signed short bit16;
typedef unsigned short bitu16;
typedef signed int bit32;
typedef unsigned int bitu32;

typedef struct {
        bitu8 r;                
        bitu8 g;                
        bitu8 b;                
        bitu8 a;                
} tr2_colour_t;

typedef struct {
        float r;                
        float g;                
        float b;                
        float a;                
} tr5_colour_t;

typedef struct {
        float x;                
        float y;                
        float z;                
} tr5_vertex_t;

typedef struct {
        bitu16 vertices[3];     
        bitu16 texture;  
        bitu16 lighting;  
} tr4_face3_t;

typedef struct {
        bitu16 vertices[4];     
        bitu16 texture;  
        bitu16 lighting;  
} tr4_face4_t;

typedef struct {
        bitu8 pixels[256][256];
} tr_textile8_t;

typedef struct {
        bitu16 pixels[256][256];
} tr2_textile16_t;

typedef struct {
        bitu32 pixels[256][256];
} tr4_textile32_t;

typedef struct {
        bitu16 adjoining_room;  
        tr5_vertex_t normal;            
        tr5_vertex_t vertices[4];       
} tr_room_portal_t;

typedef struct {
        bitu16 fd_index;        // Index into FloorData[]
        bitu16 box_index;       // Index into Boxes[]/Zones[] (-1 if none)
        bitu8 room_below;       // The number of the room below this one (-1 or 255 if none)
        bit8 floor;             // Absolute height of floor (multiply by 256 for world coordinates)
        bitu8 room_above;       // The number of the room above this one (-1 or 255 if none)
        bit8 ceiling;           // Absolute height of ceiling (multiply by 256 for world coordinates)
} tr_room_sector_t;

typedef struct {
        tr5_vertex_t pos;       // world coords
        tr2_colour_t color;     // three bytes rgb values 
        bitu16 intensity1;      // Light intensity
        bitu16 intensity2;      // Almost always equal to Intensity1 [absent from TR1 data files]
        bitu32 fade1;           // Falloff value 1
        bitu32 fade2;           // Falloff value 2 [absent from TR1 data files]
        bitu8 light_type;       // same as D3D (i.e. 2 is for spotlight) 
        bitu8 unknown;          // always 0xff? 
        float in;
        float out;
        float length;
        float cutoff;
        tr5_vertex_t dir;       // direction
        tr5_vertex_t pos2;      // world coords
        tr5_vertex_t dir2;      // direction
} tr5_room_light_t;

typedef struct {
        bit16 vertex;           // offset into vertex list
        bit16 texture;          // offset into sprite texture list
} tr_room_sprite_t;

typedef struct {
        bitu16 num_vertices;    // number of vertices in this layer (4 bytes)
        bitu16 unknown_l1;
        bitu16 unknown_l2;
        bitu16 num_rectangles;  // number of rectangles in this layer (2 bytes)
        bitu16 num_triangles;   // number of triangles in this layer (2 bytes)
        bitu16 unknown_l3;
        bitu16 unknown_l4;
        //  The following 6 floats (4 bytes each) define the bounding box for the layer
        float bounding_box_x1;
        float bounding_box_y1;
        float bounding_box_z1;
        float bounding_box_x2;
        float bounding_box_y2;
        float bounding_box_z2;
        bit16 unknown_l6a;
        bit16 unknown_l6b;
        bit16 unknown_l7a;
        bit16 unknown_l7b;
        bit16 unknown_l8a;
        bit16 unknown_l8b;
} tr5_room_layer_t;

typedef struct {
        tr5_vertex_t vertex;    // where this vertex lies (relative to tr2_room_info::x/z)
        bit16 lighting1;
        bitu16 attributes;      // A set of flags for special rendering effects [absent from TR1 data files]
        // 0x8000 something to do with water surface
        // 0x4000 under water lighting modulation and
        // movement if viewed from above water surface
        // 0x2000 water/quicksand surface movement
        // 0x0010 "normal"
        bit16 lighting2;        // Almost always equal to Lighting1 [absent from TR1 data files]
        // TR5 -->
        tr5_vertex_t normal;
        tr5_colour_t colour;    // vertex color ARGB format (4 bytes)
} tr5_room_vertex_t;

typedef struct {
        tr5_vertex_t pos;       // world coords
        float rotation;         // high two bits (0xC000) indicate steps of
        // 90 degrees (e.g. (Rotation >> 14) * 90)
        bit16 intensity1;       // Constant lighting; -1 means use mesh lighting
        bit16 intensity2;       // Like Intensity 1, and almost always the same value [absent from TR1 data files]
        bitu16 object_id;       // which StaticMesh item to draw
} tr2_room_staticmesh_t;

typedef struct {
        float x;                
        float z;                
        float y_bottom;         
        float y_top;            
        bitu32 num_layers;      // number of layers (pieces) this room (4 bytes)
        std::vector < tr5_room_layer_t > layers;        // [NumStaticMeshes]list of static meshes
        bitu32 num_vertices;    // number of vertices in the following list
        std::vector < tr5_room_vertex_t > vertices;     // [NumVertices] list of vertices (relative coordinates)
        bitu32 num_rectangles;  // number of textured rectangles
        std::vector < tr4_face4_t > rectangles; // [NumRectangles] list of textured rectangles
        bitu32 num_triangles;   // number of textured triangles
        std::vector < tr4_face3_t > triangles;  // [NumTriangles] list of textured triangles
        bitu32 num_sprites;     // number of sprites
        std::vector < tr_room_sprite_t > sprites;       // [NumSprites] list of sprites
        bitu16 num_portals;     // number of visibility portals to other rooms
        std::vector < tr_room_portal_t > portals;       // [NumPortals] list of visibility portals
        bitu16 num_zsectors;    // "width" of sector list
        bitu16 num_xsectors;    // "height" of sector list
        std::vector < tr_room_sector_t > sector_list;   // [NumXsectors * NumZsectors] list of sectors
        // in this room
        bit16 intensity1;       // This and the next one only affect externally-lit objects
        bit16 intensity2;       // Almost always the same value as AmbientIntensity1 [absent from TR1 data files]
        bit16 light_mode;       // (present only in TR2: 0 is normal, 1 is flickering(?), 2 and 3 are uncertain)
        bitu16 num_lights;      // number of point lights in this room
        std::vector < tr5_room_light_t > lights;        // [NumLights] list of point lights
        bitu16 num_static_meshes;       // number of static meshes
        std::vector < tr2_room_staticmesh_t > static_meshes;    // [NumStaticMeshes]list of static meshes
        bit16 alternate_room;   // number of the room that this room can alternate
        // with (e.g. empty/filled with water is implemented as an empty room that alternates with a full room)
        bitu16 flags;
        // flag bits: 0x0001 - room is filled with water,
        // 0x0020 - Lara's ponytail gets blown
        // by the wind;
        // TR1 has only the water flag and the extra
        // unknown flag 0x0100.
        // TR3 most likely has flags for "is raining", "is snowing", "water is cold", and "is
        // filled by quicksand", among others.
        tr2_colour_t fog_colour;        // Present in TR3-TR4 only
        tr5_colour_t light_colour;      // Present in TR5 only

        // TR5 only -->
        bitu16 unknown_r1;
        bitu16 unknown_r2;
        bit16 unknown_r3;
        bitu32 unknown_r4;
        bitu32 unknown_r5;
        bitu32 unknown_r6;
        float room_x;
        float room_z;
        bitu16 unknown_r7a;
        bitu16 unknown_r7b;
        bitu32 unknown_r8;
        bitu32 unknown_r9;
        float room_y_bottom;
        float room_y_top;
} tr5_room_t;

typedef struct {
        tr5_vertex_t centre;    // This is usually close to the mesh's centroid, and appears to be the center of a sphere used for collision testing.
        bit32 collision_size;   // This appears to be the radius of that aforementioned collisional sphere.
        bit16 num_vertices;     // number of vertices in this mesh
        std::vector < tr5_vertex_t > vertices;  //[NumVertices]; // list of vertices (relative coordinates)
        bit16 num_normals;      // If positive, number of normals in this mesh.
        // If negative, number of vertex lighting elements (* (-1))
        bit16 num_lights;       // Engine internal for above
        std::vector < tr5_vertex_t > normals;   //[NumNormals]; // list of normals (if NumNormals is positive)
        std::vector < bit16 >lights;    //[-NumNormals]; // list of light values (if NumNormals is negative)
        bit16 num_textured_rectangles;  // number of textured rectangles in this mesh
        std::vector < tr4_face4_t > textured_rectangles;        //[NumTexturedRectangles]; // list of textured rectangles
        bit16 num_textured_triangles;   // number of textured triangles in this mesh
        std::vector < tr4_face3_t > textured_triangles; //[NumTexturedTriangles]; // list of textured triangles
        // the rest is not present in TR4
        bit16 num_coloured_rectangles;  // number of coloured rectangles in this mesh
        std::vector < tr4_face4_t > coloured_rectangles;        //[NumColouredRectangles]; // list of coloured rectangles
        bit16 num_coloured_triangles;   // number of coloured triangles in this mesh
        std::vector < tr4_face3_t > coloured_triangles; //[NumColouredTriangles]; // list of coloured triangles
} tr4_mesh_t;

typedef struct {                // 32 bytes
        bitu32 object_id;       // Object Identifier (matched in Items[])
        bitu16 mesh;            // mesh (offset into MeshPointers[])
        tr5_vertex_t visibility_box[2];
        tr5_vertex_t collision_box[2];
        bitu16 flags;           // Meaning uncertain; it is usually 2, and is 3 for objects Lara can travel through,
        // like TR2's skeletons and underwater vegetation
} tr_staticmesh_t;

typedef struct {                // 4 bytes
        bitu32 flags;
        tr5_vertex_t offset;
} tr_meshtree_t;

typedef struct {
        tr5_vertex_t bbox_low;
        tr5_vertex_t bbox_high;
        tr5_vertex_t offset;
        std::vector < tr5_vertex_t > rotations;
        bit32 byte_offset;
} tr_frame_t;

typedef struct {                // 18 bytes
        bitu32 object_id;       // Item Identifier (matched in Items[])
        bitu16 num_meshes;      // number of meshes in this object
        bitu16 starting_mesh;   // stating mesh (offset into MeshPointers[])
        bitu32 mesh_tree_index; // offset into MeshTree[]
        bitu32 frame_offset;    // byte offset into Frames[] (divide by 2 for Frames[i])
        bitu32 frame_index;
        bitu16 animation_index; // offset into Animations[]
} tr_moveable_t;

typedef struct {                // 24 bytes [TR1: 22 bytes]
        bit16 object_id;        // Object Identifier (matched in Moveables[], or SpriteSequences[], as appropriate)
        bit16 room;             // which room contains this item
        tr5_vertex_t pos;       // world coords
        float rotation;         // ((0xc000 >> 14) * 90) degrees
        bit16 intensity1;       // (constant lighting; -1 means use mesh lighting)
        bit16 intensity2;       // Like Intensity1, and almost always with the same value. [absent from TR1 data files]
        bitu16 flags;           // 0x0100 indicates "initially invisible", 0x3e00 is Activation Mask
        // 0x3e00 indicates "open" or "activated";  these can be XORed with
        // related FloorData::FDlist fields (e.g. for switches)
} tr2_item_t;

typedef struct {                // 16 bytes
        bitu16 tile;
        bitu8 x;                // TR4 unknown
        bitu8 y;                // TR4 unknown
        bitu16 width;           // TR1/2/3 actually (Width * 256) + 255
        // TR4 = (real_width-1) * 256   
        bitu16 height;          // TR1/2/3 actually (Height * 256) + 255
        // TR4 = (real_height-1) * 256  
        bit16 left_side;
        bit16 top_side;
        bit16 right_side;
        bit16 bottom_side;
} tr_sprite_texture_t;

typedef struct {                // 8 bytes
        bit32 object_id;        // Item identifier (matched in Items[])
        bit16 length;           // negative of "how many sprites are in this sequence"
        bit16 offset;           // where (in sprite texture list) this sequence starts
} tr_sprite_sequence_t;

typedef struct {                // 32 bytes TR1/2/3 40 bytes TR4
        bitu32 frame_offset;    // byte offset into Frames[] (divide by 2 for Frames[i])
        bitu8 frame_rate;       // Engine ticks per frame
        bitu8 frame_size;       // number of bit16's in Frames[] used by this animation
        bitu16 state_id;

        bit16 unknown;
        bit16 speed;
        bit16 accel_lo;
        bit16 accel_hi;

        bit16 unknown2;         // new in TR4 -->
        bit16 speed2;           // not really sure what these mean.
        bit16 accel_lo2;
        bit16 accel_hi2;        // <-- TR4

        bitu16 frame_start;     // first frame in this animation
        bitu16 frame_end;       // last frame in this animation (numframes = (End - Start) + 1)
        bitu16 next_animation;
        bitu16 next_frame;

        bitu16 num_state_changes;
        bitu16 state_change_offset;     // offset into StateChanges[]
        bitu16 num_anim_commands;       // How many of them to use.
        bitu16 anim_command;    // offset into AnimCommand[]
} tr_animation_t;

typedef struct {                // 6 bytes
        bitu16 state_id;
        bitu16 num_anim_dispatches;     // number of ranges (seems to always be 1..5)
        bitu16 anim_dispatch;   // Offset into AnimDispatches[]
} tr_state_change_t;

typedef struct {                // 8 bytes
        bit16 low;              // Lowest frame that uses this range
        bit16 high;             // Highest frame (+1?) that uses this range
        bit16 next_animation;   // Animation to dispatch to
        bit16 next_frame;       // Frame offset to dispatch to
} tr_anim_dispatch_t;

typedef struct {                // 2 bytes
        bit16 value;
} tr_anim_command_t;

typedef struct {                // 8 bytes [TR1: 20 bytes] In TR1, the first four are bit32's instead of bitu8's, and are not scaled.
        bitu32 zmin;            // sectors (* 1024 units)
        bitu32 zmax;
        bitu32 xmin;
        bitu32 xmax;
        bit16 true_floor;       // Y value (no scaling)
        bit16 overlap_index;    // index into Overlaps[]. The high bit is sometimes set; this
        // occurs in front of swinging doors and the like.
} tr_box_t;

typedef struct {
        bit32 x;                // absolute X position of sound source (world coordinates)
        bit32 y;                // absolute Y position of sound source (world coordinates)
        bit32 z;                // absolute Z position of sound source (world coordinates)
        bitu16 sound_id;        // internal sound index
        bitu16 flags;           // 0x40, 0x80, or 0xc0
} tr_sound_source_t;

typedef struct {                // 8 bytes
        bit16 sample;           // (index into SampleIndices)
        bit16 volume;
        bit16 sound_range;      // sound range? (distance at which this sound can be heard?)
        bit16 flags;            // Bits 8-15: priority?, Bits 2-7: number of sound
        // samples in this group, Bits 0-1: channel number?
} tr_sound_details_t;

typedef struct {                // 4 bytes
        bit8 xcoordinate;       // 1 if Xpixel is the low value, -1 if Xpixel is the high value in the object texture
        bitu8 xpixel;
        bit8 ycoordinate;       // 1 if Ypixel is the low value, -1 if Ypixel is the high value in the object texture
        bitu8 ypixel;
} tr4_object_texture_vert_t;

typedef struct {                // 38 bytes TR4 - 20 in TR1/2/3
        bitu16 transparency_flags;      // 0 means that a texture is all-opaque, and that transparency
        // information is ignored.
        // 1 means that transparency information is used. In 8-bit colour,
        // index 0 is the transparent colour, while in 16-bit colour, the
        // top bit (0x8000) is the alpha channel (1 = opaque, 0 = transparent).
        // 2 (only in TR3) means that the opacity (alpha) is equal to the intensity;
        // the brighter the colour, the more opaque it is. The intensity is probably calculated
        // as the maximum of the individual color values.
        bitu8 tile;             // index into textile list
        bitu8 tile_flags;
        bitu16 flags;           // TR4
        tr4_object_texture_vert_t vertices[4];  // the four corners of the texture
        bitu32 unknown1;        // TR4
        bitu32 unknown2;        // TR4
        bitu32 x_size;          // TR4
        bitu32 y_size;          // TR4
} tr4_object_texture_t;

typedef struct {
        bit16 num_texture_ids;  // Actually, this is the number of texture ID's - 1.
        std::vector < bit16 >texture_ids;       //[NumTextureIDs + 1]; // offsets into ObjectTextures[], in animation order.
} tr_animated_textures_t;       //[NumAnimatedTextures];

typedef struct {
        bit32 x;
        bit32 y;
        bit32 z;
        bit16 room;
        bitu16 unknown1;        // correlates to Boxes[]? Zones[]?
} tr_camera_t;

typedef struct {
        bit32 x1;
        bit32 y1;
        bit32 z1;
        bit32 x2;
        bit32 y2;
        bitu8 index1;
        bitu8 index2;
        bitu16 unknown[5];
        bit32 id;
} tr4_extra_camera_t;

typedef struct {
        bitu16 object_id;       // the objectID from the AI object (AI_FOLLOW is 402)
        bitu16 room;
        bit32 x;
        bit32 y;
        bit32 z;
        bitu16 ocb;
        bitu16 flags;           // The trigger flags (button 1-5, first button has value 2)
        bit32 angle;
} tr4_ai_object_t;

typedef struct {
        bit16 roty;             // rotation about Y axis, +/- 32767 == +/- 180 degrees
        bit16 rotz;             // rotation about Z axis, +/- 32767 == +/- 180 degrees
        bit16 rotz2;            // seems to work a lot like rotZ;  I haven't yet been able to
        // differentiate them
        bit16 posz;             // camera position relative to something (target? Lara? room
        // origin?).  pos* are _not_ in world coordinates.
        bit16 posy;             // camera position relative to something (see posZ)
        bit16 posx;             // camera position relative to something (see posZ)
        bit16 unknown;          // changing this can cause a runtime error
        bit16 rotx;             // rotation about X axis, +/- 32767 == +/- 180 degrees
} tr_cinematic_frame_t;

typedef struct {
        bitu8 map[32 * 256];
} tr_lightmap_t;

typedef struct {
        tr2_colour_t colour[256];
} tr2_palette_t;

---