NWN1MDL.bt

//--------------------------------------
//--- 010 Editor v6.0.2 Binary Template
//
// File: NWN1MDL.bt
// Author: Enrico Horn (Farmboy0)
// Revision: 0.9
// Purpose: to map the model format of the NWN1 engine from bioware
//
// To the extent possible under law, the authors have dedicated all copyright
// and related and neighboring rights to this document to the public domain
// worldwide. This document is distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication along
// with this document.
// If not, see <https://creativecommons.org/publicdomain/zero/1.0/>.
//
//------------------------------------------------------
// Colors:
//------------------------------------------------------
//		Dark Red     : array of file pointers(not the array definition)
//		Black        : mdx data(mesh)
//		Dark Gray    : mdx data(skin)

//		Light Blue   : file header
//		Light Purple : geometry header

//		Aqua         : model header without geometry header
//		Dark Aqua    : animation incl. events array without geometry header

//		Light Green  : node header
//		Red          : controller data
//		Yellow       : light node without node header
//		Dark Yellow  : emitter node without node header
//      0xA000A0     : reference node without node header
//		Gray         : mesh node without node header
//		Orange       : skin node without node header
//      0x8090FF     : anim node without node header
//      0x909000     : dangly node without node header
//      Dark Blue    : AABB node without node header
//------------------------------------------------------

//------------------------------------------------------
// generic structures

typedef struct {
	float x;
	float y;
	float z;
} vertex <read=ReadVertex>;

typedef struct {
	float u;
	float v;
} texcoord <read=ReadTexCoord>;

typedef struct {
	float r;
	float g;
	float b;
} color <read=ReadColor>;

typedef struct {
	ubyte r;
	ubyte g;
	ubyte b;
	ubyte a;
} rgba <read=ReadRGBA>;

typedef struct {
	float w;
	float x;
	float y;
	float z;
} quaternion <read=ReadQuaternion>;

typedef struct {
	uint32 p_array_start <format=hex,read=ReadPointer>;
	uint32 nr_used_entries;
	uint32 nr_alloc_entries;
} array_definition <read=ReadArrayDef>;

typedef struct {
	array_definition def;
	if (def.nr_used_entries > 0) {
		local int pos = FTell();

		GoToPointer(def.p_array_start);
		uint32 p_index[def.nr_used_entries] <format=hex,optimize=false,fgcolor=cWhite,bgcolor=cDkRed,read=ReadPointer>;

		FSeek(pos);
	}
} array;

//------------------------------------------------------
// generic header structures

typedef struct {
	uint32 bin_mdl_id <format=hex>;
	uint32 p_start_mdx <format=hex,read=ReadPointer>;
	uint32 size_mdx;
} header_file <bgcolor=cLtBlue>;

typedef struct {
	uint32 p_func1 <format=hex>;
	uint32 p_func2 <format=hex>;
	char name[64];
	uint32 p_node_header <format=hex,read=ReadPointer>;
	uint32 count_nodes;
	array_definition unknown1;
	array_definition unknown2;
	uint32 ref_count;
	ubyte type;
	ubyte padding[3];
} header_geometry <bgcolor=cLtPurple,fgcolor=cBlack>;

typedef struct {
	header_geometry geometry;
	byte unknown0 <format=hex>;
	byte unknown1 <format=hex>;
	byte flags <format=hex>;
	byte fog <format=hex>;
	uint32 count_child_model;
	array animations;
	uint32 p_supermodel <format=hex>;
	vertex bound_min;
	vertex bound_max;
	float model_radius;
	float scale;
	char supermodel_name[64];
} header_model <bgcolor=cAqua>;

//------------------------------------------------------
// general node structures

enum controller_type_all {
	position=8,
	orientation=20,
	scale=36
};
enum controller_type_light {
	light_position=8,
	light_orientation=20,
	light_scale=36,
	light_color=76,
	light_radius=88,
	light_radius_shadow=96,
	light_vert_displacement=100,
	light_multiplier=140
};
enum controller_type_emitter {
	emitter_position=8,
	emitter_orientation=20,
	emitter_scale=36,
	emitter_alpha_end=80,
	emitter_alpha_start=84,
	emitter_birthrate=88,
	emitter_bounce_co=92,
	emitter_color_end=96,
	emitter_color_start=108,
	emitter_combine_time=120,
	emitter_drag=124,
	emitter_fps=128,
	emitter_frame_end=132,
	emitter_frame_start=136,
	emitter_grav=140,
	emitter_life_exp=144,
	emitter_mass=148,
	emitter_p2p_bezier2=152,
	emitter_p2p_bezier3=156,
	emitter_particle_rot=160,
	emitter_rand_vel=164,
	emitter_size_start=168,
	emitter_size_end=172,
	emitter_size_start_y=176,
	emitter_size_end_y=180,
	emitter_spread=184,
	emitter_threshold=188,
	emitter_velocity=192,
	emitter_size_x=196,
	emitter_size_y=200,
	emitter_blur_length=204,
	emitter_lightning_delay=208,
	emitter_lightning_radius=212,
	emitter_lightning_scale=216,
	emitter_detonate=228,
	emitter_alpha_mid=464,
	emitter_color_mid=468,
	emitter_percent_start=480,
	emitter_percent_mid=481,
	emitter_percent_end=482,
	emitter_size_mid=484,
	emitter_size_mid_y=488
};
enum controller_type_mesh {
	mesh_position=8,
	mesh_orientation=20,
	mesh_scale=36,
	mesh_self_illum_color=100,
	mesh_alpha=128
};

typedef struct {
	uint32 has_header : 1;		// 1
	uint32 has_light : 1;		// 2
	uint32 has_emitter : 1; 	// 4
	uint32 has_camera: 1;		// 8
	uint32 has_reference : 1;	// 10
	uint32 has_mesh : 1;		// 20
	uint32 has_skin : 1;		// 40
	uint32 has_anim : 1;		// 80
	uint32 has_dangly : 1;		// 100
	uint32 has_aabb : 1;		// 200
} content_node;

typedef struct {
	uint32 p_func1 <format=hex>;
	uint32 p_func2 <format=hex>;
	uint32 p_func3 <format=hex>;
	uint32 p_func4 <format=hex>;
	uint32 p_func5 <format=hex>;
	uint32 p_func6 <format=hex>;
	uint32 color_inherit;
	uint32 node_number;
	char node_name[32];
	uint32 p_geometry <format=hex,read=ReadPointer>;
	uint32 p_parent_node <format=hex,read=ReadPointer>;
	array_definition children;
	array_definition controller_keys;
	array_definition controller_data;
	content_node content;
} header_node <bgcolor=cLtGreen,fgcolor=cBlack>;

typedef struct(content_node &c) {
	if (c.has_light) {
		controller_type_light type;
	} else if (c.has_mesh) {
		controller_type_mesh type;
	} else if (c.has_emitter) {
		controller_type_emitter type;
	} else {
		controller_type_all type;
	}
	ushort value_count;
	ushort timekey_start;
	ushort data_start;
	byte column_count;
	byte padding;
} controller <bgcolor=cRed,read=ReadController>;

//------------------------------------------------------
// specific node structures

// forward declaration of the node struct
struct node;

//------------------------------------------------------
// light node

typedef struct {
	float flare_radius;
	array_definition unknown;
	array_definition flare_sizes;
	array_definition flare_positions;
	array_definition flare_color_shifts;
	array_definition flare_textures;
	uint32 light_priority;
	uint32 ambient_only;
	uint32 dynamic_type;
	uint32 affect_dynamic;
	uint32 shadow;
	uint32 generate_flare;
	uint32 fading;
} header_light <bgcolor=cYellow>;

typedef struct {
	string name;
} texture_name <fgcolor=cLtRed>;

typedef struct(node &n) {
	if (n.light.flare_textures.nr_used_entries > 0) {
		GoToPointer(n.light.flare_textures.p_array_start);
		uint32 p_texture[n.light.flare_textures.nr_used_entries] <format=hex,optimize=false,fgcolor=cWhite,bgcolor=cDkRed,read=ReadPointer>;

		local int i;
		for (i = 0; i < n.light.flare_textures.nr_used_entries; i++) {
			GoToPointer(p_texture[i]);
			texture_name texture;
		}
	}
	if (n.light.flare_sizes.nr_used_entries > 0) {
		GoToPointer(n.light.flare_sizes.p_array_start);
		float flare_size[n.light.flare_sizes.nr_used_entries] <fgcolor=cAqua>;
	}
	if (n.light.flare_positions.nr_used_entries > 0) {
		GoToPointer(n.light.flare_positions.p_array_start);
		float flare_position[n.light.flare_positions.nr_used_entries] <fgcolor=0x0090FF>;
	}
	if (n.light.flare_color_shifts.nr_used_entries > 0) {
		GoToPointer(n.light.flare_color_shifts.p_array_start);
		float flare_color_shift[3*n.light.flare_color_shifts.nr_used_entries] <fgcolor=cLtBlue>;
	}
} data_light <bgcolor=cYellow>;

//------------------------------------------------------
// emitter node

typedef struct {
	uint32 flag_p2p : 1;			// 1
	uint32 flag_p2p_sel : 1;		// 2
	uint32 flag_affected_wind : 1;	// 4
	uint32 flag_tinted : 1;			// 8
	uint32 flag_bounce : 1;			// 10
	uint32 flag_random : 1;			// 20
	uint32 flag_inherit : 1;		// 40
	uint32 flag_inherit_vel : 1;	// 80
	uint32 flag_inherit_local : 1;	// 100
	uint32 flag_splat : 1;			// 200
	uint32 flag_inherit_part : 1;	// 400
} emitter_flags;

typedef struct {
	float dead_space;
	float blast_radius;
	float blast_length;
	uint32 grid_x;
	uint32 grid_y;
	uint32 space;
	char update[32];
	char render[32];
	char blend[32];
	char texture[64];
	char chunk[16];
	uint32 texture_is_2sided;
	uint32 loop;
	uint16 render_order;
	uint16 padding;
	emitter_flags flags;
} header_emitter <bgcolor=cDkYellow>;

//------------------------------------------------------
// reference node

typedef struct {
	char referenced_model_name[64];
	uint32 reattachable;
} header_reference <bgcolor=0xA000A0>;

//------------------------------------------------------
// mesh node

enum mesh_type {
	point_list=0,
	line_list,
	line_strip,
	triangle_list,
	triangle_strip,
	triangle_fan,
	unknown
};

typedef struct {
	vertex normal;
	float distance;
	int32 surface_id;
	ushort adj_face_ids[3];
	ushort vertex_id[3];
} face;

typedef struct {
	uint32 p_func1 <format=hex>;
	uint32 p_func2 <format=hex>;
	array_definition faces;
	vertex bound_min;
	vertex bound_max;
	float radius;
	vertex average;
	color diffuse;
	color ambient;
	color specular;
	float shininess;
	uint32 shadow;
	uint32 beaming;
	uint32 render;
	uint32 transparency;
	uint32 unknown1;
	char texture0[64];
	char texture1[64];
	char texture2[64];
	char texture3[64];
	uint32 tile_fade;
	array_definition vertex_indices;
	array_definition face_leftover;
	array_definition vertex_indices_count;
	array_definition vertex_indices_offset;
	int32 p_mdx_unknown1 <format=hex, read=ReadMDXPointer>;
	uint32 unknown2 <format=hex>;
	mesh_type type;
	int32 p_start_mdx <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_vertex <format=hex, read=ReadMDXPointer>;
	uint16 count_vertexes;
	uint16 count_textures;
	int32 p_mdx_texture0 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_texture1 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_texture2 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_texture3 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_vertex_normals <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_vertex_colors <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim0 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim1 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim2 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim3 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim4 <format=hex, read=ReadMDXPointer>;
	int32 p_mdx_tex_anim5 <format=hex, read=ReadMDXPointer>;
	byte light_mapped;
	byte rotate_texture;
	uint16 padding;
	float vertex_normal_sum;
	uint32 unknown3;
} header_mesh <fgcolor=cWhite,bgcolor=cSilver>;

typedef struct(node &n) {
	if (n.mesh.faces.nr_used_entries > 0) {
		GoToPointer(n.mesh.faces.p_array_start);
		face faces[n.mesh.faces.nr_used_entries] <fgcolor=cYellow>;
	}
	if (n.mesh.vertex_indices_count.nr_used_entries > 0) {
		GoToPointer(n.mesh.vertex_indices_count.p_array_start);
		uint32 vertex_indices_count[n.mesh.vertex_indices_count.nr_used_entries] <fgcolor=cBlack>;
	}
	if (n.mesh.vertex_indices_offset.nr_used_entries > 0) {
		GoToPointer(n.mesh.vertex_indices_offset.p_array_start);
		int32 vertex_indices_offset[n.mesh.vertex_indices_offset.nr_used_entries] <fgcolor=cDkRed, format=hex, read=ReadMDXPointer>;
	}
} data_mesh <bgcolor=cSilver>;

typedef struct(node &n) {
	if (n.mesh.p_mdx_vertex != -1) {
		GoToMDXPointer(n.mesh.p_mdx_vertex);
		vertex v[n.mesh.count_vertexes] <fgcolor=cWhite>;
	}
	if (n.mesh.p_mdx_texture0 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_texture0);
		texcoord uv0[n.mesh.count_vertexes] <fgcolor=cYellow>;
	}
	if (n.mesh.p_mdx_texture1 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_texture1);
		texcoord uv1[n.mesh.count_vertexes] <fgcolor=cYellow>;
	}
	if (n.mesh.p_mdx_texture2 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_texture2);
		texcoord uv2[n.mesh.count_vertexes] <fgcolor=cYellow>;
	}
	if (n.mesh.p_mdx_texture3 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_texture3);
		texcoord uv3[n.mesh.count_vertexes] <fgcolor=cYellow>;
	}
	if (n.mesh.p_mdx_vertex_normals != -1) {
		GoToMDXPointer(n.mesh.p_mdx_vertex_normals);
		vertex normal[n.mesh.count_vertexes] <fgcolor=0x0090FF>;
	}
	if (n.mesh.p_mdx_vertex_colors != -1) {
		GoToMDXPointer(n.mesh.p_mdx_vertex_colors);
		rgba color_rgba[n.mesh.count_vertexes] <fgcolor=cLtBlue>;
	}
	if (n.mesh.vertex_indices_offset.nr_used_entries > 0) {
		local int i;
		for (i = 0; i < n.mesh.vertex_indices_offset.nr_used_entries; i++) {
			GoToMDXPointer(n.mesh_data.vertex_indices_offset[i]);
			short indices[n.mesh_data.vertex_indices_count[i]] <fgcolor=cLtGreen>;
		}
	}
	if (n.mesh.p_mdx_tex_anim0 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim0);
		rgba anim0[3*n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
	if (n.mesh.p_mdx_tex_anim1 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim1);
		rgba anim1[3*n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
	if (n.mesh.p_mdx_tex_anim2 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim2);
		rgba anim2[3*n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
	if (n.mesh.p_mdx_tex_anim3 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim3);
		rgba anim3[3*n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
	if (n.mesh.p_mdx_tex_anim4 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim4);
		rgba anim4[3*n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
	if (n.mesh.p_mdx_tex_anim5 != -1) {
		GoToMDXPointer(n.mesh.p_mdx_tex_anim5);
		rgba anim5[n.mesh.count_vertexes] <fgcolor=0x909000,read=ReadRGBA>;
	}
} mdx_mesh <bgcolor=cBlack>;

//------------------------------------------------------
// skin node

typedef struct {
	array_definition weights;
	int32 p_weight_vertex <format=hex, read=ReadMDXPointer>;
	int32 p_bone_ref_index <format=hex, read=ReadMDXPointer>;
	int32 p_bone_mapping <format=hex, read=ReadPointer>;
	int32 count_bone_mapping;
	array_definition bone_quats;
	array_definition bone_vertex;
	array_definition bone_constants;
	short bone_parts[17];
	short spare;
} header_skin <fgcolor=cWhite,bgcolor=0x0090FF>;

typedef struct(node &n) {
	if (n.skin.count_bone_mapping > 0) {
		GoToPointer(n.skin.p_bone_mapping);
		short bone_mapping[n.skin.count_bone_mapping] <fgcolor=cAqua>;
	}
	if (n.skin.bone_quats.nr_used_entries > 0) {
		GoToPointer(n.skin.bone_quats.p_array_start);
		quaternion q[n.skin.bone_quats.nr_used_entries] <fgcolor=cDkGreen>;
	}
	if (n.skin.bone_vertex.nr_used_entries > 0) {
		GoToPointer(n.skin.bone_vertex.p_array_start);
		vertex v[n.skin.bone_vertex.nr_used_entries] <fgcolor=cBlack>;
	}
	if (n.skin.bone_constants.nr_used_entries > 0) {
		GoToPointer(n.skin.bone_constants.p_array_start);
		short constants[2*n.skin.bone_constants.nr_used_entries] <fgcolor=cLtGray>;
	}
} data_skin <bgcolor=0x0090FF>;

typedef struct {
	float weight0;
	float weight1;
	float weight2;
	float weight3;
} bone_weights;

typedef struct {
	short index0;
	short index1;
	short index2;
	short index3;
} bone_index;

typedef struct(node &n) {
	if (n.skin.p_weight_vertex != -1) {
		GoToMDXPointer(n.skin.p_weight_vertex);
		bone_weights bw[n.mesh.count_vertexes] <fgcolor=cWhite>;
	}
	if (n.skin.p_bone_ref_index != -1) {
		GoToMDXPointer(n.skin.p_bone_ref_index);
		bone_index bi[n.mesh.count_vertexes] <fgcolor=cYellow>;
	}
} mdx_skin <bgcolor=0x404040>;

//------------------------------------------------------
// anim node

typedef struct {
	float sample_period;
	array_definition animation_vertices;
	array_definition animation_texcoords;
	array_definition animation_normals;
	uint32 p_animation_vertex <format=hex,read=ReadPointer>;
	uint32 p_animation_texcoord <format=hex,read=ReadPointer>;
	uint32 count_set_vertex;
	uint32 count_set_vertex_texcoord;
} header_anim <fgcolor=cWhite,bgcolor=0x8090FF>;

typedef struct(node &n) {
	if (n.anim.p_animation_vertex > 0) {
		GoToPointer(n.anim.p_animation_vertex);
		vertex anim_vertex[n.anim.count_set_vertex*n.mesh.count_vertexes] <fgcolor=cBlack>;
	}
	if (n.anim.p_animation_texcoord > 0) {
		GoToPointer(n.anim.p_animation_texcoord);
		texcoord anim_texcoord[n.anim.count_set_vertex_texcoord*n.mesh.count_vertexes] <fgcolor=cBlack>;
	}
} data_anim <bgcolor=0x8090FF>;

//------------------------------------------------------
// dangly node

typedef struct {
	array_definition constraints;
	float displacement;
	float tightness;
	float period;
} header_dangly <fgcolor=cWhite,bgcolor=0x909000>;

typedef struct(node &n) {
	if (n.dangly.constraints.nr_used_entries > 0) {
		GoToPointer(n.dangly.constraints.p_array_start);
		float constraint[n.dangly.constraints.nr_used_entries] <fgcolor=cBlack>;
	}
} data_dangly <bgcolor=0x909000>;

//------------------------------------------------------
// aabb node

struct entry_aabb;

typedef struct {
	vertex bound_min;
	vertex bound_max;
	uint32 p_left_node <format=hex,read=ReadPointer>;
	uint32 p_right_node <format=hex,read=ReadPointer>;
	int32 part_number_leaf_face;
	uint32 plane;
	if (p_left_node > 0) {
		GoToPointer(p_left_node);
		entry_aabb left;
	}
	if (p_right_node > 0) {
		GoToPointer(p_right_node);
		entry_aabb right;
	}
} entry_aabb <fgcolor=cLtRed,bgcolor=cDkBlue>;

typedef struct {
	uint32 p_aabb <format=hex,read=ReadPointer>;
} header_aabb <fgcolor=cWhite,bgcolor=cDkBlue>;

typedef struct(node &n) {
	GoToPointer(n.aabb.p_aabb);
	entry_aabb root;
} data_aabb <bgcolor=cDkBlue>;

//------------------------------------------------------
// model node

typedef struct {
	header_node header;
	if (header.content.has_light) {
		header_light light;
	}
	if (header.content.has_emitter) {
		header_emitter emitter;
	}
	if (header.content.has_reference) {
		header_reference reference;
	}
	if (header.content.has_mesh) {
		header_mesh mesh;
	}
	if (header.content.has_skin) {
		header_skin skin;
	}
	if (header.content.has_anim) {
		header_anim anim;
	}
	if (header.content.has_dangly) {
		header_dangly dangly;
	}
	if (header.content.has_aabb) {
		header_aabb aabb;
	}
	if (header.content.has_aabb) {
		data_aabb aabb_data(this);
	}
	if (header.content.has_dangly) {
		if (dangly.constraints.nr_used_entries > 0) {
			data_dangly dangly_data(this);
		}
	}
	if (header.content.has_anim) {
		if (anim.p_animation_vertex > 0) {
			data_anim anim_data(this);
		}
	}
	if (header.content.has_skin) {
		if (skin.count_bone_mapping > 0 ||
			skin.bone_quats.nr_used_entries > 0 ||
			skin.bone_vertex.nr_used_entries > 0 ||
			skin.bone_constants.nr_used_entries > 0) {

			data_skin skin_data(this);
		}
	}
	if (header.content.has_mesh) {
		if (mesh.faces.nr_used_entries > 0) {
			data_mesh mesh_data(this);
		}
	}
	if (header.content.has_light) {
		if (light.flare_textures.nr_used_entries > 0 ||
			light.flare_sizes.nr_used_entries > 0 ||
			light.flare_positions.nr_used_entries > 0 ||
			light.flare_color_shifts.nr_used_entries > 0) {

			data_light light_data(this);
		}
	}
	if (header.children.nr_used_entries > 0) {
		GoToPointer(header.children.p_array_start);
		uint32 p_children[header.children.nr_used_entries] <format=hex,optimize=false,fgcolor=cWhite,bgcolor=cDkRed,read=ReadPointer>;

		local int i;
		for (i = 0; i < header.children.nr_used_entries; i++) {
			GoToPointer(p_children[i]);
			node children;
		}
	}
	if (header.controller_keys.nr_used_entries > 0) {
		GoToPointer(header.controller_keys.p_array_start);

		local int c;
		for (c = 0; c < header.controller_keys.nr_used_entries; c++) {
			controller key(header.content) <bgcolor=cRed, fgcolor=cWhite>;
		}
	}
	if (header.controller_data.nr_used_entries > 0) {
		GoToPointer(header.controller_data.p_array_start);
		float data[header.controller_data.nr_used_entries] <bgcolor=cRed, fgcolor=cYellow>;
	}
	if (header.content.has_skin &&
			(skin.p_weight_vertex != -1 ||
			 skin.p_bone_ref_index != -1)) {

		mdx_skin skin_mdx(this);
	}
	if (header.content.has_mesh && mesh.count_vertexes > 0) {
		GoToPointer(mesh.p_start_mdx);
		mdx_mesh mdx(this);
	}
} node <read=ReadNode>;

//------------------------------------------------------
// animation structures

typedef struct {
	float start;
	char name[32];
} event <read=ReadEvent>;

typedef struct(int nr_of_events) {
    local int e;
    for (e = 0; e < nr_of_events; e++) {
    	event ev;
    }
} event_array;

typedef struct {
	header_geometry geometry;
	float length;
	float transition;
	char name_root_node[64];
	array_definition events;
} header_animation;

typedef struct {
	header_animation header;

	if (header.events.nr_used_entries > 0) {
		GoToPointer(header.events.p_array_start);
		event_array events(header.events.nr_used_entries);
	}

	GoToPointer(header.geometry.p_node_header);
	node animation_node;
} animation <read=ReadAnim, bgcolor=cDkAqua,fgcolor=cWhite>;

//------------------------------------------------------
// main definition

LittleEndian();
header_file hf;
if (hf.bin_mdl_id == 0) {
	header_model hm;

	GoToPointer(hm.geometry.p_node_header);
	node root;

	local int a;
	for (a = 0; a < hm.animations.def.nr_used_entries; a++) {
		GoToPointer(hm.animations.p_index[a]);
		animation anim;
	}
}

//------------------------------------------------------
// GoTo(MDX)Pointer

void GoToPointer(uint32 p) {
	FSeek(sizeof(header_file) + p);
}

uint32 mdxPointer(int32 p) {
	local uint32 pos = 0;
	if (p > -1) {
		pos = p;
	}
	return sizeof(header_file) + hf.p_start_mdx + pos;
}

void GoToMDXPointer(int32 p) {
	FSeek(mdxPointer(p));
}

//------------------------------------------------------
// read Methods

string ReadVertex( vertex &v ) {
	local string s;
	SPrintf(s, "x=%f,y=%f,z=%f", v.x, v.y, v.z);
	return s;
}

string ReadTexCoord( texcoord &uv ) {
	local string s;
	SPrintf(s, "u=%f,v=%f", uv.u, uv.v);
	return s;
}

string ReadColor( color &c ) {
	local string s;
	SPrintf(s, "r=%f,g=%f,b=%f", c.r, c.g, c.b);
	return s;
}

string ReadRGBA( rgba &c ) {
	local string s;
	SPrintf(s, "r=%u,g=%u,b=%u,a=%u", c.r, c.g, c.b,c.a);
	return s;
}

string ReadQuaternion( quaternion &q ) {
	local string s;
	SPrintf(s, "%f,%f,%f,%f", q.w, q.x, q.y, q.z);
	return s;
}

string ReadPointer( uint32 &p ) {
	local uint32 v = 0;
	if (p > 0) {
		v = sizeof(header_file) + p;
	}
	local string s;
	SPrintf(s, "%Xh", v);
	return s;
}

string ReadMDXPointer( int32 &p ) {
	local int32 v = -1;
	if (p >= 0) {
		v = mdxPointer(p);
	}
	local string s;
	SPrintf(s, "%Xh", v);
	return s;
}

string ReadArrayDef( array_definition &a ) {
	local string s;
	SPrintf(s, "%s(%i)", ReadPointer(a.p_array_start), a.nr_used_entries);
	return s;
}

string ReadController( controller &key ) {
	local string s;
	SPrintf(s, "%i", key.type);
	return s;
}

string ReadNode( node &n ) {
	local string s = n.header.node_name;
	if (n.header.content.has_light) {
		s+="+Ligh";
	}
	if (n.header.content.has_emitter) {
		s+="+Emit";
	}
	if (n.header.content.has_camera) {
		s+="+Came";
	}
	if (n.header.content.has_reference) {
		s+="+Refs";
	}
	if (n.header.content.has_mesh) {
		s+="+Mesh";
	}
	if (n.header.content.has_skin) {
		s+="+Skin";
	}
	if (n.header.content.has_anim) {
		s+="+Anim";
	}
	if (n.header.content.has_dangly) {
		s+="+Dang";
	}
	if (n.header.content.has_aabb) {
		s+="+AABB";
	}
	if (n.header.children.nr_used_entries > 0) {
		local string child_count;
		SPrintf(child_count, "(%d)", n.header.children.nr_used_entries);
		s+=child_count;
	}
	return s;
}

string ReadEvent( event &e ) {
	local string s;
	SPrintf(s, "%s(%f)", e.name, e.start);
	return s;
}

string ReadAnim( animation &anim ) {
	return anim.header.geometry.name;
}