Kitty Corp Meow Mix Forums

<?xml version="1.0"?>
<!DOCTYPE binary_file_format SYSTEM "BinaryFileFormat.dtd">
<binary_file_format name="MDL0" type_name="" comment="" expr="" default_byte_order="big" default_read_only="false" default_char_set="ansi">
<define_struct type_name="offset_name" comment="" expr="">
<data type="int" name="str_len" format="unsigned" len="1" display=""/>
<data type="string" name="name" format="ascii" len="str_len" display=""/>
</define_struct>
<define_struct type_name="bounds" comment="" expr="">
<data type="int" name="min_X" format="unsigned" len="4" display=""/>
<data type="int" name="min_Y" format="unsigned" len="4" display=""/>
<data type="int" name="min_Z" format="unsigned" len="4" display=""/>
<data type="int" name="max_X" format="unsigned" len="4" display=""/>
<data type="int" name="max_Y" format="unsigned" len="4" display=""/>
<data type="int" name="max_Z" format="unsigned" len="4" display=""/>
<data type="none" name="pad" len="8"/>
</define_struct>
<define_struct type_name="relocation_group" comment="" expr="">
<data type="int" name="block_len" format="unsigned" len="4" display=""/>
<data type="int" name="num_offsets" format="unsigned" len="4" display=""/>
<data type="int" name="tag" format="unsigned" len="4" display="hex"/>
<data type="int" name="unk1" format="unsigned" len="2" display="hex"/>
<data type="int" name="unk2" format="unsigned" len="2" display="hex"/>
<data type="int" name="pad" format="unsigned" len="8" display="hex"/>
</define_struct>
<define_struct type_name="relocation_offset" comment="" expr="">
<data type="int" name="ID" format="unsigned" len="2" display=""/>
<data type="int" name="unk1" format="unsigned" len="2" display="hex"/>
<data type="int" name="unk2" format="unsigned" len="2" display="hex"/>
<data type="int" name="unk3" format="unsigned" len="2" display="hex"/>
<data type="int" name="string_offset" format="unsigned" len="4" display=""/>
<data type="int" name="data_offset" format="unsigned" len="4" display=""/>
</define_struct>
<define_struct type_name="Definitions" comment="" expr="">
<for name="type" count="" stop_test="this.type == 1" type_name="" comment="">
<struct name="" type_name="" comment="" expr="type{this.type}">
<data type="int" name="type" format="unsigned" len="1" display=""/>
<if test="type == 2" comment="">
<struct name="t2" type_name="" comment="" expr="({this.ID1},{this.ID2})">
<data type="int" name="ID1" format="unsigned" len="2" display=""/>
<data type="int" name="ID2" format="unsigned" len="2" display=""/>
</struct>
</if>
<if test="type == 3" comment="">
<struct name="t3" type_name="" comment="" expr="({this.ID}) ({this.count})">
<data type="int" name="ID" format="unsigned" len="2" display=""/>
<data type="int" name="count" format="unsigned" len="1" display=""/><for name="tmp" count="count || count - 1" stop_test="count == 0" type_name="" comment=""><data type="none" name="" len="6"/></for></struct>
</if>
<if test="type == 4" comment="">
<struct name="t4" type_name="" comment="" expr="({this.ID1},{this.ID2},{this.ID3},{this.ID4})">
<data type="int" name="ID1" format="unsigned" len="2" display=""/>
<data type="int" name="ID2" format="unsigned" len="2" display=""/>
<data type="int" name="ID3" format="unsigned" len="2" display=""/>
<data type="int" name="ID4" format="unsigned" len="1" display=""/>
</struct>
</if>
<if test="type == 5" comment="">
<struct name="t5" type_name="" comment="" expr="({this.ID1},{this.ID2})">
<data type="int" name="ID1" format="unsigned" len="2" display=""/>
<data type="int" name="ID2" format="unsigned" len="2" display=""/>
</struct>
</if>
</struct>
</for>
</define_struct>
<define_struct type_name="Bones" comment="" expr="">
<struct name="bone_header" type_name="" comment="" expr="">
<data type="int" name="header_len" len="4" format="unsigned" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="string_offset" len="4" format="unsigned" display=""/>
<data type="int" name="bone_index" len="4" format="unsigned" display=""/>
<data type="int" name="node_ID" len="4" format="unsigned" display=""/>
<data type="int" name="flags" len="4" format="unsigned" display=""/>
<data type="int" name="pad" len="8" format="unsigned" display=""/>
<struct name="loc_rot_sca" type_name="" comment="" expr="">
<data type="int" name="sca_X" format="unsigned" len="4" display=""/>
<data type="int" name="sca_Y" len="4" format="unsigned" display=""/>
<data type="int" name="sca_Z" len="4" format="unsigned" display=""/>
<data type="int" name="rot_X" len="4" format="unsigned" display=""/>
<data type="int" name="rot_Y" len="4" format="unsigned" display=""/>
<data type="int" name="rot_Z" len="4" format="unsigned" display=""/>
<data type="int" name="loc_X" len="4" format="unsigned" display=""/>
<data type="int" name="loc_Y" len="4" format="unsigned" display=""/>
<data type="int" name="loc_Z" len="4" format="unsigned" display=""/>
</struct>
<struct name="bound" type_name="" comment="" expr="">
<data type="int" name="min_X" len="4" format="unsigned" display=""/>
<data type="int" name="min_Y" len="4" format="unsigned" display=""/>
<data type="int" name="min_Z" len="4" format="unsigned" display=""/>
<data type="int" name="max_X" len="4" format="unsigned" display=""/>
<data type="int" name="max_Y" len="4" format="unsigned" display=""/>
<data type="int" name="max_Z" len="4" format="unsigned" display=""/>
</struct>
<data type="int" name="parent" len="4" format="signed" display=""/>
<data type="int" name="child" len="4" format="unsigned" display=""/>
<data type="int" name="next" len="4" format="unsigned" display=""/>
<data type="int" name="prev" len="4" format="unsigned" display=""/>
<data type="int" name="part2" len="4" format="unsigned" display=""/>
</struct>
<struct name="frame_matrix" type_name="" comment="" expr="">
<data type="int" name="s_1_1" format="signed" len="4" display=""/>
<data type="int" name="s_2_1" format="signed" len="4" display=""/>
<data type="int" name="s_3_1" format="signed" len="4" display=""/>
<data type="int" name="s_4_1" format="signed" len="4" display=""/>
<data type="int" name="s_1_2" format="signed" len="4" display=""/>
<data type="int" name="s_2_2" format="signed" len="4" display=""/>
<data type="int" name="s_3_2" format="signed" len="4" display=""/>
<data type="int" name="s_4_2" format="signed" len="4" display=""/>
<data type="int" name="s_1_3" format="signed" len="4" display=""/>
<data type="int" name="s_2_3" format="signed" len="4" display=""/>
<data type="int" name="s_3_3" format="signed" len="4" display=""/>
<data type="int" name="s_4_3" format="signed" len="4" display=""/>
</struct>
<struct name="inverse_matrix" type_name="" comment="" expr="">
<data type="int" name="s_1_1" format="signed" len="4" display=""/>
<data type="int" name="s_2_1" format="signed" len="4" display=""/>
<data type="int" name="s_3_1" format="signed" len="4" display=""/>
<data type="int" name="s_4_1" format="signed" len="4" display=""/>
<data type="int" name="s_1_2" format="signed" len="4" display=""/>
<data type="int" name="s_2_2" format="signed" len="4" display=""/>
<data type="int" name="s_3_2" format="signed" len="4" display=""/>
<data type="int" name="s_4_2" format="signed" len="4" display=""/>
<data type="int" name="s_1_3" format="signed" len="4" display=""/>
<data type="int" name="s_2_3" format="signed" len="4" display=""/>
<data type="int" name="s_3_3" format="signed" len="4" display=""/>
<data type="int" name="s_4_3" format="signed" len="4" display=""/>
</struct>
</define_struct>
<define_struct type_name="Vertices" comment="" expr="">
<struct name="vertice_header" type_name="" comment="" expr="">
<data type="int" name="block_size" len="4" format="unsigned" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="data_offset" len="4" format="unsigned" display=""/>
<data type="int" name="string_offset" len="4" format="unsigned" display=""/>
<data type="int" name="ID" len="4" format="unsigned" display=""/>
<data type="int" name="isXYZ" len="4" format="unsigned" display=""/>
<data type="int" name="type" len="4" format="unsigned" display=""/>
<data type="int" name="modifier" len="1" format="unsigned" display=""/>
<data type="int" name="entry_stride" len="1" format="unsigned" display=""/>
<data type="int" name="num_vertices" len="2" format="unsigned" display=""/>
<if test="isXYZ == 1" comment="">
<use_struct name="bounds" expr="" type_name="bounds" comment=""/>
</if>
</struct>
<data type="string" name="vertices" len="vertice_header.entry_stride * vertice_header.num_vertices" format="default" display="vert structures" comment="I could've put a 'FOR' here,
but it'd take too long when loading the file"/>
<data type="none" name="pad" len="vertice_header.block_size - (vertice_header.entry_stride*vertice_header.num_vertices) - vertice_header.data_offset"/>
</define_struct>
<define_struct type_name="Normals" comment="" expr="">
<struct name="normal_header" type_name="" comment="" expr="">
<data type="int" name="block_size" len="4" format="unsigned" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="data_offset" len="4" format="unsigned" display=""/>
<data type="int" name="string_offset" len="4" format="unsigned" display=""/>
<data type="int" name="ID" len="4" format="unsigned" display=""/>
<data type="int" name="isXYZ" len="4" format="unsigned" display=""/>
<data type="int" name="type" len="4" format="unsigned" display=""/>
<data type="int" name="modifier" len="1" format="unsigned" display=""/>
<data type="int" name="entry_stride" len="1" format="unsigned" display=""/>
<data type="int" name="num_normals" len="2" format="unsigned" display=""/>
<if test="isXYZ == 1" comment="">
<use_struct name="bounds" expr="" type_name="bounds" comment=""/>
</if>
</struct>
<data type="string" name="normals" format="default" display="normal structures" len="normal_header.entry_stride*normal_header.num_normals" comment="I could've put a 'FOR' here,
but it'd take too long when loading the file"/>
<data type="none" name="pad" len="normal_header.block_size - (normal_header.entry_stride*normal_header.num_normals) - normal_header.data_offset"/>
</define_struct>
<define_struct type_name="Colors" comment="" expr="">
<struct name="color_header" type_name="" comment="" expr="">
<data type="int" name="block_size" len="4" format="signed" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="data_offset" len="4" format="signed" display=""/>
<data type="int" name="string_offset" len="4" format="signed" display=""/>
<data type="int" name="ID" len="4" format="signed" display=""/>
<data type="int" name="isRGBA" len="4" format="signed" display=""/>
<data type="int" name="type" len="4" format="signed" display=""/>
<data type="int" name="entry_stride" len="1" format="signed" display=""/>
<data type="int" name="modifier" len="1" format="signed" display=""/>
<data type="int" name="num_colors" len="2" format="signed" display=""/>
</struct>
<for name="color" count="color_header.num_colors || color_header.num_colors - 1" stop_test="color_header.num_colors == 0" type_name="" comment="">
<data type="none" name="color" len="color_header.entry_stride"/>
</for>
<data type="none" name="pad" len="color_header.block_size - (color_header.num_colors*color_header.entry_stride) - 32"/>
</define_struct>
<define_struct type_name="UV_Points" comment="" expr="">
<struct name="UV_header" type_name="" comment="" expr="">
<data type="int" name="block_size" len="4" format="unsigned" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="data_offset" len="4" format="unsigned" display=""/>
<data type="int" name="string_offset" len="4" format="unsigned" display=""/>
<data type="int" name="ID" len="4" format="unsigned" display=""/>
<data type="int" name="isXY" len="4" format="unsigned" display=""/>
<data type="int" name="type" len="4" format="unsigned" display=""/>
<data type="int" name="modifier" len="1" format="unsigned" display=""/>
<data type="int" name="entry_stride" len="1" format="unsigned" display=""/>
<data type="int" name="num_UVs" len="2" format="unsigned" display=""/>
<if test="isXY == 1" comment="">
<struct name="bounds" expr="" type_name="" comment="">
<data type="int" name="min_X" format="unsigned" len="4" display=""/>
<data type="int" name="min_Y" format="unsigned" len="4" display=""/>
<data type="int" name="max_X" format="unsigned" len="4" display=""/>
<data type="int" name="max_Y" format="unsigned" len="4" display=""/>
<data type="none" name="pad" len="16"/>
</struct>
</if>
</struct>
<data type="string" name="UVs" len="UV_header.entry_stride * UV_header.num_UVs" format="default" display="uv structures" comment="I could've put a 'FOR' here,
but it'd take too long when loading the file"/>
<data type="none" name="pad" len="UV_header.block_size - (UV_header.entry_stride*UV_header.num_UVs) - UV_header.data_offset"/>
</define_struct>
<define_struct type_name="Shaders" comment="" expr="">
<struct name="header" type_name="" comment="" expr="">
<data type="int" name="block_size" len="4" format="unsigned" display=""/>
<data type="int" name="MDL0_offset" len="4" format="signed" display=""/>
<data type="int" name="string_offset" len="4" format="unsigned" display=""/>
<data type="int" name="ID" len="4" format="unsigned" display=""/>
<data type="int" name="unk1" len="4" format="unsigned" display=""/>
<data type="int" name="textures" len="1" format="unsigned" display=""/>
<data type="int" name="num_layers" len="1" format="unsigned" display=""/>
<data type="int" name="Flag3" len="1" format="unsigned" display=""/>
<data type="int" name="Flag4" len="1" format="unsigned" display=""/>
<data type="int" name="type" len="4" format="unsigned" display=""/>
<data type="int" name="Flag5" len="1" format="unsigned" display=""/>
<data type="int" name="Flag6" len="1" format="unsigned" display=""/>
<data type="int" name="Flag7" len="1" format="unsigned" display=""/>
<data type="int" name="Flag8" len="1" format="unsigned" display=""/>
<data type="int" name="unk3" format="unsigned" len="4" display=""/>
<data type="int" name="unk4" format="signed" len="4" display=""/>
<data type="int" name="material_offset" format="signed" len="4" display=""/>
<data type="int" name="num_textures" format="signed" len="4" display=""/>
<data type="int" name="textures_offset" format="signed" len="4" display=""/>
<data type="int" name="P4_offset" format="signed" len="4" display=""/>
<data type="int" name="P5_offset" format="signed" len="4" display=""/>
<data type="int" name="P6_offset" format="signed" len="4" display=""/>
</struct>
<jump offset="header.material_offset+(header.MDL0_offset*-1)" comment="" origin="start">
<use_struct name="Material_Reference" expr="" type_name="Materials" comment=""/>
</jump>
<if test="header.textures_offset != 0" comment="">
<jump offset="header.textures_offset+(header.MDL0_offset*-1)" comment="" origin="start">
<for name="texture" count="header.textures || header.textures -1" stop_test="header.textures == 0" type_name="" comment="">
<struct name="texture" type_name="" comment="" expr="{this.offset_name.name}">
<data type="int" name="string_offset" format="signed" len="4" display=""/>
<data type="int" name="pad" len="4" format="signed" display=""/>
<data type="int" name="unk1" format="signed" len="4" display=""/>
<data type="int" name="unk2" format="signed" len="4" display=""/>
<data type="int" name="unk3" format="signed" len="4" display=""/>
<data type="int" name="unk4" format="signed" len="4" display=""/>
<data type="int" name="layerID1" format="signed" len="4" display=""/>
<data type="int" name="layerID2" format="signed" len="4" display=""/>
<data type="int" name="unk5" format="signed" len="4" display=""/>
<data type="int" name="unk6" format="signed" len="4" display=""/>
<data type="int" name="float" format="unsigned" len="4" display=""/>
<data type="int" name="unk7" format="signed" len="4" display=""/>
<data type="int" name="unk8" format="signed" len="4" display=""/>
<jump offset="string_offset -53" comment="" origin="current">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</jump>
</if>
<if test="header.P4_offset != 0" comment="">
<jump offset="header.P4_offset+(header.MDL0_offset*-1)" comment="" origin="start">
<struct name="P4" type_name="" comment="" expr="">
<data type="int" name="tmp" format="signed" len="4" display=""/>
</struct>
</jump>
</if>
<if test="header.P5_offset != 0" comment="">
<jump offset="header.P5_offset+(header.MDL0_offset*-1)" comment="" origin="start">
<struct name="P5" type_name="" comment="" expr="">
<data type="none" name="tmp" len="384"/>
</struct>
</jump>
</if>
<if test="header.P6_offset != 0" comment="">
<jump offset="header.P6_offset+(header.MDL0_offset*-1)" comment="" origin="start">
<struct name="P6" type_name="" comment="" expr="">
<data type="none" name="tmp" len="384"/>
</struct>
</jump>
</if>
</define_struct>
<define_struct type_name="Materials" comment="" expr="">
<struct name="header" type_name="" comment="" expr="">
<data type="int" name="block_length" format="signed" len="4" display=""/>
<data type="int" name="MDL0_offset" format="signed" len="4" display=""/>
<data type="int" name="ID" format="signed" len="4" display=""/>
<data type="int" name="unk" format="unsigned" len="1" display=""/>
</struct>
<data type="none" name="tmp" len="header.block_length - 13"/>
</define_struct>
<define_struct type_name="Polygons" comment="" expr="">
<struct name="header" type_name="" comment="" expr="">
<data type="none" name="tmp" len="4"/>
</struct>
</define_struct>
<define_struct type_name="Textures" comment="" expr="">
<data type="int" name="textures" format="signed" len="4" display=""/>
<for name="texture" count="textures || textures - 1" stop_test="textures == 0" type_name="" comment="">
<struct name="texture" type_name="" comment="" expr="X: {this.X}, Y: {this.Y}">
<data type="int" name="X" format="unsigned" len="4" display=""/>
<data type="int" name="Y" format="unsigned" len="4" display=""/>
</struct>
</for>
</define_struct>
<define_struct type_name="Pallets" comment="" expr="">
<data type="int" name="pallets" format="signed" len="4" display=""/>
<for name="pallet" count="pallets || pallets - 1" stop_test="pallets == 0" type_name="" comment="">
<struct name="texture" type_name="" comment="" expr="X: {this.X}, Y: {this.Y}">
<data type="int" name="X" format="unsigned" len="4" display=""/>
<data type="int" name="Y" format="unsigned" len="4" display=""/>
</struct>
</for>
</define_struct>
<struct name="header" type_name="" comment="" expr="">
<data type="string" name="magic" len="4" format="ascii" display=""/>
<data type="int" name="filesize" format="unsigned" len="4" display=""/>
<data type="int" name="sections" format="unsigned" len="4" display=""/>
<data type="int" name="nodes" format="signed" len="4" display=""/>
<struct name="lists" type_name="" comment="" expr="">
<data type="int" name="Definitions" format="unsigned" len="4" display=""/>
<data type="int" name="Bones" format="unsigned" len="4" display=""/>
<data type="int" name="Vertices" format="unsigned" len="4" display=""/>
<data type="int" name="Normals" format="unsigned" len="4" display=""/>
<data type="int" name="Colors" format="unsigned" len="4" display=""/>
<data type="int" name="UV_Points" format="unsigned" len="4" display=""/>
<data type="int" name="Shaders" format="unsigned" len="4" display=""/>
<data type="int" name="Materials" format="unsigned" len="4" display=""/>
<data type="int" name="Polygons" format="unsigned" len="4" display=""/>
<data type="int" name="Textures" format="unsigned" len="4" display=""/>
<data type="int" name="Pallets" format="unsigned" len="4" display=""/>
</struct>
<data type="int" name="name_offset" format="unsigned" len="4" display=""/>
<data type="int" name="header_len" format="unsigned" len="4" display=""/>
<data type="int" name="header_offset" format="signed" len="4" display=""/>
<data type="int" name="unk1" format="unsigned" len="4" display=""/>
<data type="int" name="unk2" format="unsigned" len="4" display=""/>
<data type="int" name="num_verticies" format="unsigned" len="4" display=""/>
<data type="int" name="num_faces" format="unsigned" len="4" display=""/>
<data type="int" name="unk3" format="unsigned" len="4" display=""/>
<data type="int" name="num_nodes" format="unsigned" len="4" display=""/>
<data type="int" name="version" format="unsigned" len="4" display=""/>
<data type="int" name="unk4" format="unsigned" len="2" display=""/>
<data type="int" name="unk5" format="unsigned" len="2" display=""/>
<struct name="bounds" type_name="" comment="" expr="">
<data type="int" name="min_X" format="unsigned" len="4" display=""/>
<data type="int" name="min_Y" format="unsigned" len="4" display=""/>
<data type="int" name="min_Z" format="unsigned" len="4" display=""/>
<data type="int" name="max_X" format="unsigned" len="4" display=""/>
<data type="int" name="max_Y" format="unsigned" len="4" display=""/>
<data type="int" name="max_Z" format="unsigned" len="4" display=""/>
</struct>
</struct>
<jump offset="header.nodes * -1" comment="" origin="start">
<struct name="nodes" type_name="" comment="" expr="">
<data type="int" name="num_nodes" format="signed" len="4" display=""/>
<for name="node" count="num_nodes || num_nodes - 1" stop_test="num_nodes == 0" type_name="" comment="">
<data type="int" name="node" format="signed" len="4" display=""/>
</for>
</struct>
</jump>
<if test="header.lists.Definitions != 0" comment="">
<jump offset="header.lists.Definitions" comment="" origin="start">
<struct name="Definitions" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Definitions" comment="" origin="start">
<use_struct name="Definitions" expr="" type_name="Definitions" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Definitions - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Bones != 0" comment="">
<jump offset="header.lists.Bones" comment="" origin="start">
<struct name="Bones" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Bones" comment="" origin="start">
<use_struct name="Bone_data" expr="" type_name="Bones" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Bones - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Vertices != 0" comment="">
<jump offset="header.lists.Vertices" comment="" origin="start">
<struct name="Vertices" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Vertices" comment="" origin="start">
<use_struct name="Vertices" expr="" type_name="Vertices" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Vertices - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Normals != 0" comment="">
<jump offset="header.lists.Normals" comment="" origin="start">
<struct name="Normals" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Normals" comment="" origin="start">
<use_struct name="Normals" expr="" type_name="Normals" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Normals - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Colors != 0" comment="">
<jump offset="header.lists.Colors" comment="" origin="start">
<struct name="Colors" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Colors" comment="" origin="start">
<use_struct name="Colors" expr="" type_name="Colors" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Colors - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.UV_Points != 0" comment="">
<jump offset="header.lists.UV_Points" comment="" origin="start">
<struct name="UV_Points" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.UV_Points" comment="" origin="start">
<use_struct name="UV_Points" expr="" type_name="UV_Points" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.UV_Points - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Shaders != 0" comment="">
<jump offset="header.lists. Shaders" comment="" origin="start">
<struct name="Shaders" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Shaders" comment="" origin="start">
<use_struct name="Shaders" expr="" type_name="Shaders" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Shaders - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Materials != 0" comment="">
<jump offset="header.lists.Materials" comment="" origin="start">
<struct name="Materials" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Materials" comment="" origin="start">
<use_struct name="Materials" expr="" type_name="Materials" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Materials - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Polygons != 0" comment="">
<jump offset="header.lists.Polygons" comment="" origin="start">
<struct name="Polygons" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Polygons" comment="" origin="start">
<use_struct name="Polygons" expr="" type_name="Polygons" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Polygons - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Textures != 0" comment="">
<jump offset="header.lists.Textures" comment="" origin="start">
<struct name="Textures" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Textures" comment="" origin="start">
<use_struct name="Textures" expr="" type_name="Textures" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Textures - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<if test="header.lists.Pallets != 0" comment="">
<jump offset="header.lists.Pallets" comment="" origin="start">
<struct name="Pallets" type_name="" comment="" expr="">
<use_struct name="relocation_group" expr="" type_name="relocation_group" comment=""/>
<for name="data" count="relocation_group.num_offsets || relocation_group.num_offsets - 1" stop_test="relocation_group.num_offsets == 0" type_name="" comment="">
<struct name="data" type_name="" comment="" expr="{this.offset_name.name}">
<use_struct name="relocation_offset" expr="" type_name="relocation_offset" comment=""/>
<jump offset="relocation_offset.data_offset + header.lists.Pallets" comment="" origin="start">
<use_struct name="Pallets" expr="" type_name="Pallets" comment=""/>
</jump>
<jump offset="relocation_offset.string_offset + header.lists.Pallets - 1" comment="" origin="start">
<use_struct name="offset_name" expr="" type_name="offset_name" comment=""/>
</jump>
</struct>
</for>
</struct>
</jump>
</if>
<data type="none" name="none"/>
</binary_file_format>

/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/

#ifndef __DAE__
#define __DAE__

// We use the boost filesystem library for cross-platform file system support. You'll need
// to have boost on your machine for this to work. For the Windows build boost is provided
// in the external-libs folder, but for Linux it's expected that you'll install a boost
// obtained via your distro's package manager. For example on Debian/Ubuntu, you can run
//   apt-get install libboost-filesystem-dev
// to install the boost filesystem library on your machine.
//
// Disable the warnings we get from Boost
// warning C4180: qualifier applied to function type has no meaning; ignored
// warning C4245: 'argument' : conversion from 'int' to 'boost::filesystem::system_error_type',
//   signed/unsigned mismatch
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4180 4245)
#endif
#ifndef NO_BOOST
#include <boost/filesystem/convenience.hpp>       // THIS WAS NOT COMMENTED.
#endif
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include <dae/daeTypes.h>
#include <dae/daeError.h>
#include <dae/daeDatabase.h>
#include <dae/daeIOPlugin.h>
#include <dae/daeAtomicType.h>
#include <dae/daeMetaElement.h>
#include <dae/daeIDRef.h>
#include <dae/daeURI.h>
#include <dae/daeUtils.h>
#include <dae/daeRawResolver.h>
#include <dae/daeSIDResolver.h>

class domCOLLADA;
typedef daeSmartRef<domCOLLADA> domCOLLADARef;
class daeDatabase;

// The DAE class is the core interface via which you interact with the DOM. It
// has methods to load/save documents, get the root element of each document,
// etc. Although internally the DOM works exclusively with URIs, the methods of
// the DAE class that take document paths can take URIs or OS-specific file
// paths.
class DLLSPEC DAE
{
public:
// Constructor. If no database or IO plugin are provided, a default database and
// IO plugin will be used.
DAE(daeDatabase* database = NULL, daeIOPlugin* ioPlugin = NULL)
  : atomicTypes(*this),
    baseUri(*this, cdom::getCurrentDirAsUri().c_str())
{
// See the end of the thread linked below for an explanation of why we have the DAE
// constructor set up this way. Basically, I'm going to be changing the build output
// location, and when this happens people sometimes continue to link against the old
// libraries by accident (e.g. if they just do an svn update). By introducing a new
// function that gets called from a function in a header file, I'm ensuring that someone
// who tries linking against old libraries will get a link error. This may not sound
// very nice, but it's certainly better than getting bizarre runtime crashes.
// https://collada.org/public_forum/viewtopic.php?t=771&sid=f13c34f2d17ca720c5021bccbe5128b7
init(database, ioPlugin);
dummyFunction1();
}

virtual ~DAE();

// Release all memory used by the DOM. You never need to call this explicitly. It's
// called automatically when all DAE objects go out of scope.
    // Deletes directory returned by cdom::getSafeTmpDir().
static void cleanup();

public:
// Database setup
virtual daeDatabase* getDatabase();
virtual daeInt setDatabase(daeDatabase* database);

// IO Plugin setup
virtual daeIOPlugin* getIOPlugin();
virtual daeInt setIOPlugin(daeIOPlugin* plugin);

// Creates a new document, returning null on failure.
virtual domCOLLADA* add(const std::string& path);
// Opens an existing document, returning null on failure.
virtual domCOLLADA* open(const std::string& path);
// Opens a document from memory, returning null on failure.
virtual domCOLLADA* openFromMemory(const std::string& path, daeString buffer);
// Write a document to the path specified by the document's URI, returning false on failure.
virtual bool write(const std::string& path);
// Write a document to the path specified in the second parameter, returning false on failure.
virtual bool writeTo(const std::string& docPath, const std::string& pathToWriteTo);
// Writes all documents, returning false if any document failed to write.
virtual bool writeAll();
// Close a specific document, unloading all memory used by the document. Returns false on failure.
virtual void close(const std::string& path);
// Remove all loaded documents. Always returns DAE_OK.
virtual daeInt clear();

// Returns the total number of documents.
virtual int getDocCount();
// Returns the i'th document .
virtual daeDocument* getDoc(int i);
// Returns a document matching the path.
virtual daeDocument* getDoc(const std::string& path);

// Get the root domCOLLADA object corresponding to a particular document.
virtual domCOLLADA* getRoot(const std::string& path);
// Set the root domCOLLADA object corresponding to a particular document, returning false on failure.
virtual bool        setRoot(const std::string& path, domCOLLADA* root);

// Returns the Collada version, i.e. 1.4, 1.5, etc. Note that this _isn't_ the
// same as the DOM version (1.3, 2.0, ...).
virtual daeString getDomVersion();

// Returns the (modifiable) list of atomic type objects.
daeAtomicTypeList& getAtomicTypes();

// Get/set a daeMetaElement object given the meta object's type ID.
daeMetaElement* getMeta(daeInt typeID);
void setMeta(daeInt typeID, daeMetaElement& meta);

// Get all daeMetaElement objects.
daeMetaElementRefArray& getAllMetas();

// Returns the list of URI resolvers. You can modify the list to add new resolvers.
daeURIResolverList& getURIResolvers();

// The base URI used for resolving relative URI references.
daeURI& getBaseURI();
void setBaseURI(const daeURI& uri);
void setBaseURI(const std::string& uri);

// Returns the list of ID reference resolvers. You can modify the list to add new
// resolvers.
daeIDRefResolverList& getIDRefResolvers();

// Meant for internal DOM use only.
daeRawRefCache& getRawRefCache();
daeSidRefCache& getSidRefCache();

// These functions specify the client's character encoding for the DOM. The
// default is Utf8, but if you specify Latin1 then the DOM will use libxml's
// character conversion functions to convert to Utf8 when writing data and
// convert to Latin1 when reading data. This can help with the handling of
// non-ASCII characters on Windows. Only when using libxml for xml I/O does
// any character conversion occur.
//
// Most people can probably just ignore this completely. If you have trouble
// with non-ASCII characters on Windows, try setting the char encoding to
// Latin1 to see if that helps.
//
// Frankly this certainly isn't the best way of handling non-ASCII character
// support on Windows, so this interface is a likely target for significant
// changes in the future.
//
// See this Sourceforge thread for more info:
// http://sourceforge.net/tracker/index.php?func=detail&aid=1818473&group_id=157838&atid=805426
//
enum charEncoding {
Utf8,
Latin1
};

// Global encoding setting. Defaults to Utf8. Set this if you want to make a
// char encoding change and apply it to all DAE objects.
static charEncoding getGlobalCharEncoding();
static void setGlobalCharEncoding(charEncoding encoding);

// Local encoding setting. If set, overrides the global setting. Useful for setting
// a specific char encoding for a single DAE object but not for all DAE objects.
charEncoding getCharEncoding();
void setCharEncoding(charEncoding encoding);

// Deprecated. Alternative methods are given.
virtual daeInt load(daeString uri, daeString docBuffer = NULL); // Use open
virtual daeInt save(daeString uri, daeBool replace=true); // Use write
virtual daeInt save(daeUInt documentIndex, daeBool replace=true); // Use write
virtual daeInt saveAs(daeString uriToSaveTo, daeString docUri, daeBool replace=true); // Use writeTo
virtual daeInt saveAs(daeString uriToSaveTo, daeUInt documentIndex=0, daeBool replace=true); // Use writeTo
virtual daeInt unload(daeString uri); // Use close
virtual domCOLLADA* getDom(daeString uri); // use getRoot
virtual daeInt      setDom(daeString uri, domCOLLADA* dom); // use setRoot

private:
void init(daeDatabase* database, daeIOPlugin* ioPlugin);
void dummyFunction1();
std::string makeFullUri(const std::string& path);
domCOLLADA* openCommon(const std::string& path, daeString buffer);
bool writeCommon(const std::string& docPath, const std::string& pathToWriteTo, bool replace);

daeDatabase *database;
daeIOPlugin *plugin;
bool defaultDatabase;
bool defaultPlugin;
daeAtomicTypeList atomicTypes;
daeMetaElementRefArray metas;
daeURI baseUri;
daeURIResolverList uriResolvers;
daeIDRefResolverList idRefResolvers;
daeRawRefCache rawRefCache;
daeSidRefCache sidRefCache;

std::auto_ptr<charEncoding> localCharEncoding;
static charEncoding globalCharEncoding;
};


template <typename T>
inline T *daeSafeCast(daeElement *element)
{
if (element  &&  element->typeID() == T::ID())
return (T*)element;
return NULL;
}


#endif // __DAE_INTERFACE__

bool MDL0File::loadPolyGroup(const char* data, PolyGroup* group) {
uint16_t vertexid = BigUInt16(data, 72);
uint16_t normalid = BigUInt16(data, 74);
uint16_t colorid = BigUInt16(data, 76);
uint16_t texcoordid[8];
for (int i = 0; i < 8; i++)
texcoordid[i] = BigUInt16(data, 80 + 2 * i);

uint16_t unknowncount = BigUInt16(data, 102);

// find the start of the array format
int loc = 104 + unknowncount * 2;
while (data[loc] == 0) {
loc++;
}

// read array format
std::vector<int> fmt;
bool normalfmt = false;
bool colorfmt = false;
int unknownfmt = 0;
int uvfmt = 0;
int tempfmt = 0;

if (data[loc] != 0x08 && data[loc + 1] != 0x50)
return false;

tempfmt = data[loc + 5] & 3;
if (tempfmt) {
unknownfmt = 1;
}
tempfmt = (data[loc + 5] & 12) >> 2;
if (tempfmt) {
unknownfmt++;
}
tempfmt = (data[loc + 5] & 48) >> 4;
if (tempfmt) {
unknownfmt++;
}
tempfmt = (data[loc + 5] & 192) >> 6;
if (tempfmt) {
unknownfmt++;
}

tempfmt = (data[loc + 4] & 6) >> 1;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 4] & 24) >> 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 4] & 96) >> 5;
if (tempfmt)
fmt.push_back(tempfmt - 1);

if (data[loc + 6] != 0x08 && data[loc + 7] != 0x60)
return false;

tempfmt = data[loc + 11] & 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 12) >> 2;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 48) >> 4;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 192) >> 6;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = data[loc + 10] & 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 12) >> 2;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 48) >> 4;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 192) >> 6;
if (tempfmt)
fmt.push_back(tempfmt - 1);

if (data[loc + 16] != 0x08 && data[loc + 17] != 0x00)
return false;

colorfmt = data[loc + 20] & 3;
normalfmt = (data[loc + 20] & 12) >> 2;
uvfmt = (data[loc + 20] & 240) >> 4;

// find the start of the data
loc += 40;
while (data[loc] == 0) {
loc++;
}

// read data
bool reading = true;
do {
char type = data[loc];
loc++;
switch (type) {
case 0x30:
loc += 4;
break;
case 0x20:
loc += 4;
break;
case 0x28:
loc += 4;
break;
case 0x98: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
int length;
for (int i = 0; i < count - 2; i++) {
Vertex p1, p2, p3;
if (i % 2) {
p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc -= length;
} else {
p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc -= length;
}
Triangle tri(p1, p2, p3);
group->AddTriangle(tri);
}
loc += length * 2;
} else {
TriangleStrip strip;
for (int i = 0; i < count; i++) {
int length;
strip.Add(loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length));
loc += length;
}
strip.Lock();
group->AddTriangleStrip(strip);
}
}
break;
case 0x90: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

for (int i = 0; i < count; i += 3) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Triangle tri(p1, p2, p3);
group->AddTriangle(tri);
}
}
break;
case 0xA0: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
int length;
Vertex origin = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;

for (int i = 1; i < count - 1; i++) {

Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
Triangle tri(origin, p1, p2);
group->AddTriangle(tri);
}
loc += length;
} else {
int length;
Vertex origin = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
TriangleFan fan(origin);
for (int i = 1; i < count; i++) {

fan.Add(loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length));
loc += length;
}
fan.Lock();
group->AddTriangleFan(fan);
}
}
break;
case 0x80: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
for (int i = 0; i < count; i += 4) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p4 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Triangle tri1(p1, p2, p3);
Triangle tri2(p1, p3, p4);
group->AddTriangle(tri1);
group->AddTriangle(tri2);
}
} else {
for (int i = 0; i < count; i += 4) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p4 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Quad quad(p1, p2, p3, p4);
group->AddQuad(quad);
}
}
}
break;
case 0x00:
reading = false;
break;
default:
return false;
}
} while (reading);

group->SetVertex(vertexid, &vertexGroups[vertexid]);

if (normalid != 0xFFFF)
group->SetNormal(normalid, &normalGroups[normalid]);

if (colorid != 0xFFFF)
group->SetColor(colorid, &colorGroups[colorid]);

for (int i = 0; i < 8; i++) {
if (texcoordid[i] != 0xFFFF) {
group->AddUV(texcoordid[i], &uvGroups[texcoordid[i]]);
}
}

group->Lock();

return true;
}

#include <iostream>

#include <dae.h>
#include <dom/domCOLLADA.h>
#include <ctime>
#include <sstream>

#include <iostream>
#include <string>
#include <fstream>

#include <cmath>


typedef unsigned char uchar;
typedef unsigned int uint;

class Vec3 {
public:
Vec3() {
this->x = 0;
this->y = 0;
this->z = 0;
}
Vec3(float x, float y, float z) {
this->x = x;
this->y = y;
this->z = z;
}
float X() {
return x;
}
float Y() {
return y;
}
float Z() {
return z;
}
protected:
float x;
float y;
float z;
};

class Vec2 {
public:
Vec2() {
this->u = 0;
this->v = 0;
}
Vec2(float u, float v) {
this->u = u;
this->v = v;
}
float U() {
return u;
}
float V() {
return v;
}
protected:
float u;
float v;
};

class RGBA {
public:
RGBA(uchar r, uchar g, uchar b, uchar a) {
this->r = r;
this->g = g;
this->b = b;
this->a = a;
}
uchar R() {
return r;
}
uchar G() {
return g;
}
uchar B() {
return b;
}
uchar A() {
return a;
}
protected:
uchar r;
uchar g;
uchar b;
uchar a;
};

class Vec3Group: public std::vector<Vec3> {
public:
Vec3Group() {
set = false;
}
void SetBound(Vec3 min, Vec3 max) {
if (!set) {
this->min = min;
this->max = max;
set = true;
}
}
Vec3 BoundingMin() {
return min;
}
Vec3 BoundingMax() {
return max;
}
protected:
bool set;
Vec3 min;
Vec3 max;
};

class Vec2Group: public std::vector<Vec2> {
public:
Vec2Group() {
set = false;
}
void SetBound(Vec2 min, Vec2 max) {
if (!set) {
this->min = min;
this->max = max;
set = true;
}
}
Vec2 BoundingMin() {
return min;
}
Vec2 BoundingMax() {
return max;
}
protected:
bool set;
Vec2 min;
Vec2 max;
};

typedef std::vector<RGBA> RGBAGroup;

class Vertex {
public:
Vertex() {
vertex = 0;
normal = 0;
color = 0;
//uv = NULL;
uvCount = 0;
}
~Vertex() {
/*if (uv != NULL) {
delete[] uv;
uv = NULL;
}*/
}

void Set(uint16_t vertex, uint16_t normal, uint16_t color, uint16_t uv[],
int numUV) {
this->vertex = vertex;
this->normal = normal;
this->color = color;

//this->uv = new uint16_t[numUV];
for (int i = 0; i < numUV; i++) {
this->uv[i] = uv[i];
}
this->uvCount = numUV;
}

uint16_t GetVertex() {
return vertex;
}
uint16_t GetNormal() {
return normal;
}
uint16_t GetColor() {
return color;
}
uint16_t GetUV(int id) {
if (id >= 0 && id < uvCount) {
return uv[id];
}
else
return 0;
}
int UVCount() {
return uvCount;
}
private:
uint16_t vertex;
uint16_t normal;
uint16_t color;
uint16_t uv[8];
int uvCount;
};

class TriangleStrip {
public:
TriangleStrip() {
locked = false;
}

~TriangleStrip() {

}

Vertex& operator[](size_t index) {
return verts[index];
}

void Add(Vertex vert) {
if (!locked) {
verts.push_back(vert);
}
}

void Lock() {
locked = true;
}

size_t Count() {
return verts.size();
}
private:
bool locked;
std::vector<Vertex> verts;
};

class TriangleFan {
public:
TriangleFan(Vertex origin) {
this->origin = origin;
locked = false;
}

~TriangleFan() {

}

Vertex& operator[](size_t index) {
return verts[index];
}

void Add(Vertex vert) {
if (!locked) {
verts.push_back(vert);
}
}

void Lock() {
locked = true;
}

size_t Count() {
return verts.size();
}

Vertex GetOriginVertex() {
return origin;
}
private:
bool locked;
Vertex origin;
std::vector<Vertex> verts;
};

class Triangle {
public:
Triangle(Vertex p1, Vertex p2, Vertex p3) {
this->p1 = p1;
this->p2 = p2;
this->p3 = p3;
}

~Triangle() {

}

Vertex& operator[](size_t index) {
switch (index) {
case 0:
return p1;
case 1:
return p2;
case 2:
return p3;
default:
return p3;
}
}
private:
Vertex p1;
Vertex p2;
Vertex p3;
};

class Quad {
public:
Quad(Vertex p1, Vertex p2, Vertex p3, Vertex p4) {
this->p1 = p1;
this->p2 = p2;
this->p3 = p3;
this->p4 = p4;
}

~Quad() {

}

Vertex& operator[](size_t index) {
switch (index) {
case 0:
return p1;
case 1:
return p2;
case 2:
return p3;
case 3:
return p4;
default:
return p4;
}
}
private:
Vertex p1;
Vertex p2;
Vertex p3;
Vertex p4;
};

class PolyGroup {
public:
PolyGroup() {
locked = false;

vertex = 0;
vertexPtr = NULL;
normal = 0;
normalPtr = NULL;
color = 0;
colorPtr = NULL;
}

~PolyGroup() {

}

void SetVertex(uint16_t vertex, Vec3Group* vertexPtr) {
if (!locked) {
this->vertex = vertex;
this->vertexPtr = vertexPtr;
}
}

void SetNormal(uint16_t normal, Vec3Group* normalPtr) {
if (!locked) {
this->normal = normal;
this->normalPtr = normalPtr;
}
}

void SetColor(uint16_t color, RGBAGroup* colorPtr) {
if (!locked) {
this->color = color;
this->colorPtr = colorPtr;
}
}

void AddUV(uint16_t uvid, Vec2Group* uvPtr) {
if (!locked) {
this->uvIDs.push_back(uvid);
this->uvPtrs.push_back(uvPtr);
}
}

void Lock() {
locked = true;
}

void AddTriangleStrip(TriangleStrip tristrip) {
if (!locked) {
triangleStrips.push_back(tristrip);
}
}

void AddTriangleFan(TriangleFan trifan) {
if (!locked) {
triangleFans.push_back(trifan);
}
}

void AddTriangle(Triangle triangle) {
if (!locked) {
triangles.push_back(triangle);
}
}

void AddQuad(Quad quad) {
if (!locked) {
quads.push_back(quad);
}
}

size_t TriangleStripCount() {
return triangleStrips.size();
}

size_t TriangleFanCount() {
return triangleFans.size();
}

size_t TriangleCount() {
return triangles.size();
}

size_t QuadCount() {
return quads.size();
}

TriangleStrip GetTriangleStrip(size_t index) {
return triangleStrips[index];
}

TriangleFan GetTriangleFan(size_t index) {
return triangleFans[index];
}

Triangle GetTriangle(size_t index) {
return triangles[index];
}

Quad GetQuad(size_t index) {
return quads[index];
}

uint16_t VertexGroup() {
return vertex;
}
Vec3Group* VertexGroupPtr() {
return vertexPtr;
}
uint16_t NormalGroup() {
return normal;
}
Vec3Group* NormalGroupPtr() {
return normalPtr;
}
uint16_t ColorGroup() {
return color;
}
RGBAGroup* ColorGroupPtr() {
return colorPtr;
}
uint16_t UVGroup(uint id) {
if (id < uvIDs.size())
return uvIDs[id];
}

Vec2Group* UVGroupPtr(uint id) {
if (id < uvPtrs.size())
return uvPtrs[id];
else
return NULL;
}

int UVGroupCount() {
return uvIDs.size();
}
private:
bool locked;
uint16_t vertex;
Vec3Group* vertexPtr;
uint16_t normal;
Vec3Group* normalPtr;
uint16_t color;
RGBAGroup* colorPtr;
std::vector<uint16_t> uvIDs;
std::vector<Vec2Group*> uvPtrs;

std::vector<TriangleStrip> triangleStrips;
std::vector<TriangleFan> triangleFans;
std::vector<Triangle> triangles;
std::vector<Quad> quads;
};








extern float BigFloat(const char* data, unsigned int offset=0);
extern uint32_t BigUInt32(const char* data, unsigned int offset=0);
extern uint16_t BigUInt16(const char* data, unsigned int offset=0);
extern int16_t BigSInt16(const char* data, unsigned int offset=0);







float BigFloat(const char* data, unsigned int offset) {
union {
float f;
unsigned char b[4];
} dat;

dat.b[0] = data[offset + 3];
dat.b[1] = data[offset + 2];
dat.b[2] = data[offset + 1];
dat.b[3] = data[offset];
return dat.f;
}

uint32_t BigUInt32(const char* data, unsigned int offset) {
union {
uint32_t u;
unsigned char b[4];
} dat;

dat.b[0] = data[offset + 3];
dat.b[1] = data[offset + 2];
dat.b[2] = data[offset + 1];
dat.b[3] = data[offset];
return dat.u;
}

uint16_t BigUInt16(const char* data, unsigned int offset) {
union {
uint16_t u;
unsigned char b[2];
} dat;

dat.b[0] = data[offset + 1];
dat.b[1] = data[offset];
return dat.u;
}

int16_t BigSInt16(const char* data, unsigned int offset) {
union {
int16_t u;
unsigned char b[2];
} dat;

dat.b[0] = data[offset + 1];
dat.b[1] = data[offset];
return dat.u;
}







typedef enum {
LO_CONV_TO_TRIS = 1 // converts all triangle strips/fans and quads to triangles
} LoadOptions;

class MDL0File {
public:
MDL0File();
virtual ~MDL0File();

/**
* Load an MDL0 file.
*
* @param data An array containing the all the data in the file.
* @return True on a success, false on failure.
*/
bool Load(const char* data, uint length, uint options);
void Unload();

PolyGroup* GetPolygonGroup(int id);
int PolygonGroupCount();
Vec3Group* GetVertexGroup(int id);
int VertexGroupCount();
RGBAGroup* GetColorGroup(int id);
int ColorGroupCount();
Vec3Group* GetNormalGroup(int id);
int NormalGroupCount();
Vec2Group* GetUVGroup(int id);
int UVGroupCount();

private:
bool loadGroup(const char* data, int type);
bool loadVec3Group(const char* data, Vec3Group* group);
bool loadVec2Group(const char* data, Vec2Group* group);
bool loadRGBAGroup(const char* data, RGBAGroup* group);
bool loadPolyGroup(const char* data, PolyGroup* group);
Vertex loadVertex(const char* data, int offset, std::vector<int> fmt,
bool hasNormal, bool hasColor, int unknown, int uv, int& outLength);

bool loaded;
uint options;

PolyGroup* polyGroups;
int polyGroupCount;
Vec3Group* vertexGroups;
int vertexGroupCount;
RGBAGroup* colorGroups;
int colorGroupCount;
Vec3Group* normalGroups;
int normalGroupCount;
Vec2Group* uvGroups;
int uvGroupCount;
};







MDL0File::MDL0File() {
loaded = false;

polyGroups = NULL;
polyGroupCount = 0;
vertexGroups = NULL;
vertexGroupCount = 0;
colorGroups = NULL;
colorGroupCount = 0;
normalGroups = NULL;
normalGroupCount = 0;
uvGroups = NULL;
uvGroupCount = 0;
options = 0;
}

MDL0File::~MDL0File() {
if (vertexGroups != NULL) {
delete[] vertexGroups;
vertexGroups = NULL;
}
if (normalGroups != NULL) {
delete[] normalGroups;
normalGroups = NULL;
}
if (colorGroups != NULL) {
delete[] colorGroups;
colorGroups = NULL;
}
if (uvGroups != NULL) {
delete[] uvGroups;
uvGroups = NULL;
}
if (polyGroups != NULL) {
delete[] polyGroups;
polyGroups = NULL;
}
}

bool MDL0File::Load(const char* data, uint length, uint convToTris) {
if (data == NULL) {
return false;
}

// we need the array to be at least as long as the header
if (length < 64)
return false;

// check for "MDL0"
if (data[0] != 'M' || data[1] != 'D' || data[2] != 'L' || data[3] != '0')
return false;

this->options = options;

const char *groupPtrs[11];
for (int i = 0; i < 11; i++) {
uint32_t ptr = BigUInt32(data, 16 + i * 4);

if (ptr >= length)
return false; // pointer is out of range

if (ptr == 0)
groupPtrs[i] = NULL;
else
groupPtrs[i] = data + ptr;
}

for (int i = 0; i < 11; i++) {
if (groupPtrs[i] != NULL) {
loadGroup(groupPtrs[i], i);
}
}

loaded = true;

return true;
}

void MDL0File::Unload() {}

PolyGroup* MDL0File::GetPolygonGroup(int id) {
if (id < polyGroupCount)
return &polyGroups[id];
else
return NULL;
}

int MDL0File::PolygonGroupCount() {
return polyGroupCount;
}

Vec3Group* MDL0File::GetVertexGroup(int id) {
if (id < vertexGroupCount)
return &vertexGroups[id];
else
return NULL;
}

int MDL0File::VertexGroupCount() {
return vertexGroupCount;
}

RGBAGroup* MDL0File::GetColorGroup(int id) {
if (id < colorGroupCount)
return &colorGroups[id];
else
return NULL;
}

int MDL0File::ColorGroupCount() {
return colorGroupCount;
}

Vec3Group* MDL0File::GetNormalGroup(int id) {
if (id < normalGroupCount)
return &normalGroups[id];
else
return NULL;
}

int MDL0File::NormalGroupCount() {
return normalGroupCount;
}

Vec2Group* MDL0File::GetUVGroup(int id) {
if (id < uvGroupCount)
return &uvGroups[id];
else
return NULL;
}

int MDL0File::UVGroupCount() {
return uvGroupCount;
}

bool MDL0File::loadGroup(const char* data, int type) {
uint32_t itemcount = BigUInt32(data, 4);

switch (type) {
case 0: // unknown
break;
case 1: // probably bones, don't know how to load yet
break;
case 2: // vertices
vertexGroups = new Vec3Group[itemcount];
vertexGroupCount = itemcount;
break;
case 3: // normals
normalGroups = new Vec3Group[itemcount];
normalGroupCount = itemcount;
break;
case 4: // colors
colorGroups = new RGBAGroup[itemcount];
colorGroupCount = itemcount;
break;
case 5: // uv coordinates
uvGroups = new Vec2Group[itemcount];
uvGroupCount = itemcount;
break;
case 6: // unknown
break;
case 7: // unknown
break;
case 8: // polygon groups
polyGroups = new PolyGroup[itemcount];
polyGroupCount = itemcount;
break;
case 9: // unknown
break;
case 10: // unknown
break;
}

for (uint i = 0; i < itemcount; i++) {
uint32_t dataoffset = BigUInt32(data, 36 + 16 * i);

switch (type) {
case 0: // unknown
break;
case 1: // probably bones, don't know how to load yet
break;
case 2: // vertices
if (!loadVec3Group(data + dataoffset, &vertexGroups[i]))
return false;
break;
case 3: // normals
if (!loadVec3Group(data + dataoffset, &normalGroups[i]))
return false;
break;
case 4: // colors
if (!loadRGBAGroup(data + dataoffset, &colorGroups[i]))
return false;
break;
case 5: // uv coordinates
if (!loadVec2Group(data + dataoffset, &uvGroups[i]))
return false;
break;
case 6: // unknown
break;
case 7: // unknown
break;
case 8: // polygon groups
if (!loadPolyGroup(data + dataoffset, &polyGroups[i]))
return false;
break;
case 9: // unknown
break;
case 10: // unknown
break;
}
}

return true;
}

bool MDL0File::loadVec3Group(const char* data, Vec3Group* group) {
bool boundingbox = data[23];
char datatype = data[27];
char fixedpointbits = data[28];
uint16_t datacount = BigUInt16(data, 30);

int datastart = 32;
if (boundingbox) {
float minx = BigFloat(data, 32);
float miny = BigFloat(data, 36);
float minz = BigFloat(data, 40);
float maxx = BigFloat(data, 44);
float maxy = BigFloat(data, 48);
float maxz = BigFloat(data, 52);

group->SetBound(Vec3(minx, miny, minz), Vec3(maxx, maxy, maxz));

datastart = 64;
} else {
group->SetBound(Vec3(0, 0, 0), Vec3(0, 0, 0));
}

switch (datatype) {
case 0: // fixed point u8
for (int i = 0; i < datacount; i++) {
float x = (unsigned char) data[datastart + i * 6] / pow(2.0f,
fixedpointbits);
float y = (unsigned char) data[datastart + 1 + i * 6] / pow(2.0f,
fixedpointbits);
float z = (unsigned char) data[datastart + 2 + i * 6] / pow(2.0f,
fixedpointbits);
group->push_back(Vec3(x, y, z));
}
break;
case 1: // fixed point s8
for (int i = 0; i < datacount; i++) {
float x = data[datastart + i * 6] / pow(2.0f, fixedpointbits);
float y = data[datastart + 1 + i * 6] / pow(2.0f, fixedpointbits);
float z = data[datastart + 2 + i * 6] / pow(2.0f, fixedpointbits);
group->push_back(Vec3(x, y, z));
}
break;
case 2: // fixed point u16
for (int i = 0; i < datacount; i++) {
float x = BigUInt16(data, datastart + i * 6) / pow(2.0f,
fixedpointbits);
float y = BigUInt16(data, datastart + 2 + i * 6) / pow(2.0f,
fixedpointbits);
float z = BigUInt16(data, datastart + 4 + i * 6) / pow(2.0f,
fixedpointbits);
group->push_back(Vec3(x, y, z));
}
break;
case 3: // fixed point s16
for (int i = 0; i < datacount; i++) {
float x = BigSInt16(data, datastart + i * 6) / pow(2.0f,
fixedpointbits);
float y = BigSInt16(data, datastart + 2 + i * 6) / pow(2.0f,
fixedpointbits);
float z = BigSInt16(data, datastart + 4 + i * 6) / pow(2.0f,
fixedpointbits);
group->push_back(Vec3(x, y, z));
}
break;
case 4: // floating point
for (int i = 0; i < datacount; i++) {
float x = BigFloat(data, datastart + i * 12);
float y = BigFloat(data, datastart + 4 + i * 12);
float z = BigFloat(data, datastart + 8 + i * 12);
group->push_back(Vec3(x, y, z));
}
break;
default:
return false;
}

return true;
}

bool MDL0File::loadVec2Group(const char* data, Vec2Group* group) {
bool boundingbox = data[23];
char datatype = data[27];
char fixedpointbits = data[28];
uint16_t datacount = BigUInt16(data, 30);

int datastart = 32;
if (boundingbox) {
float minu = BigFloat(data, 32);
float minv = BigFloat(data, 36);
float maxu = BigFloat(data, 40);
float maxv = BigFloat(data, 44);

group->SetBound(Vec2(minu, minv), Vec2(maxu, maxv));

datastart = 64;
} else {
group->SetBound(Vec2(0, 0), Vec2(0, 0));
}

switch (datatype) {
case 0: // fixed point u8
for (int i = 0; i < datacount; i++) {
float u = (unsigned char) data[datastart + i * 6] / pow(2.0f,
fixedpointbits);
float v = (unsigned char) data[datastart + 1 + i * 6] / pow(2.0f,
fixedpointbits);
group->push_back(Vec2(u, v));
}
break;
case 1: // fixed point s8
for (int i = 0; i < datacount; i++) {
float u = data[datastart + i * 6] / pow(2.0f, fixedpointbits);
float v = data[datastart + 1 + i * 6] / pow(2.0f, fixedpointbits);
group->push_back(Vec2(u, v));
}
break;
case 2: // fixed point u16
for (int i = 0; i < datacount; i++) {
float u = BigUInt16(data, datastart + i * 4) / pow(2.0f,
fixedpointbits);
float v = BigUInt16(data, datastart + 2 + i * 4) / pow(2.0f,
fixedpointbits);
group->push_back(Vec2(u, v));
}
case 3: // fixed point s16
for (int i = 0; i < datacount; i++) {
float u = BigSInt16(data, datastart + i * 4) / pow(2.0f,
fixedpointbits);
float v = BigSInt16(data, datastart + 2 + i * 4) / pow(2.0f,
fixedpointbits);
group->push_back(Vec2(u, v));
}
break;
case 4: // floating point
for (int i = 0; i < datacount; i++) {
float u = BigFloat(data, datastart + i * 8);
float v = BigFloat(data, datastart + 4 + i * 8);
group->push_back(Vec2(u, v));
}
break;
default:
return false;
}

return true;
}

bool MDL0File::loadRGBAGroup(const char* data, RGBAGroup* group) {
char datatype = data[27];
uint16_t datacount = BigUInt16(data, 30);

int datastart = 32;

switch (datatype) {
case 0: // RGB565
for (int i = 0; i < datacount; i++) {
char r = ((data[datastart + 2 * i] & 0xF8) >> 3) / 0x1F * 0xFF;
char g = (((data[datastart + 2 * i] & 0x7) << 3) | ((data[datastart
+ 1 + 2 * i] & 0xE0) >> 5)) / 0x3F * 0xFF;
char b = (data[datastart + 1 + 2 * i] & 0x1F) / 0x1F * 0xFF;
group->push_back(RGBA(r, g, b, 0xFF));
}
break;
case 1: // RGB8
for (int i = 0; i < datacount; i++) {
char r = data[datastart + 3 * i];
char g = data[datastart + 1 + 3 * i];
char b = data[datastart + 2 + 3 * i];
group->push_back(RGBA(r, g, b, 0xFF));
}
break;
case 2: // RGBX8
for (int i = 0; i < datacount; i++) {
char r = data[datastart + 4 * i];
char g = data[datastart + 1 + 4 * i];
char b = data[datastart + 2 + 4 * i];
group->push_back(RGBA(r, g, b, 0xFF));
}
break;
case 3: // RGBA4
for (int i = 0; i < datacount; i++) {
char r = (data[datastart + 2 * i] >> 4) * 0x11;
char g = data[datastart + 2 * i] * 0x11;
char b = (data[datastart + 1 + 2 * i] >> 4) * 0x11;
char a = data[datastart + 1 + 2 * i] * 0x11;
group->push_back(RGBA(r, g, b, a));
}
break;
case 4: // RGBA6
for (int i = 0; i < datacount; i++) {
char r = ((data[datastart + 3 * i] & 0x3F) >> 2) / 0x3F * 0xFF;
char g = (((data[datastart + 3 * i] & 0x3) << 4) | ((data[datastart
+ 1 + 3 * i] & 0xF0) >> 4)) / 0x3F * 0xFF;
char b = (((data[datastart + 1 + 3 * i] & 0xF) << 4)
| ((data[datastart + 2 + 3 * i] & 0xC0) >> 6)) / 0x3F
* 0xFF;
char a = (data[datastart + 2 + 3 * i] & 0x3F) / 0x3F * 0xFF;
group->push_back(RGBA(r, g, b, a));
}
break;
case 5: // RGBA8
for (int i = 0; i < datacount; i++) {
unsigned char r = data[datastart + 4 * i];
unsigned char g = data[datastart + 1 + 4 * i];
unsigned char b = data[datastart + 2 + 4 * i];
unsigned char a = data[datastart + 3 + 4 * i];
group->push_back(RGBA(r, g, b, a));
}
break;
default:
return false;
}

return true;
}

bool MDL0File::loadPolyGroup(const char* data, PolyGroup* group) {
uint16_t vertexid = BigUInt16(data, 72);
uint16_t normalid = BigUInt16(data, 74);
uint16_t colorid = BigUInt16(data, 76);
uint16_t texcoordid[8];
for (int i = 0; i < 8; i++)
texcoordid[i] = BigUInt16(data, 80 + 2 * i);

uint16_t unknowncount = BigUInt16(data, 102);

// find the start of the array format
int loc = 104 + unknowncount * 2;
while (data[loc] == 0) {
loc++;
}

// read array format
std::vector<int> fmt;
bool normalfmt = false;
bool colorfmt = false;
int unknownfmt = 0;
int uvfmt = 0;
int tempfmt = 0;

if (data[loc] != 0x08 && data[loc + 1] != 0x50)
return false;

tempfmt = data[loc + 5] & 3;
if (tempfmt) {
unknownfmt = 1;
}
tempfmt = (data[loc + 5] & 12) >> 2;
if (tempfmt) {
unknownfmt++;
}
tempfmt = (data[loc + 5] & 48) >> 4;
if (tempfmt) {
unknownfmt++;
}
tempfmt = (data[loc + 5] & 192) >> 6;
if (tempfmt) {
unknownfmt++;
}

tempfmt = (data[loc + 4] & 6) >> 1;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 4] & 24) >> 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 4] & 96) >> 5;
if (tempfmt)
fmt.push_back(tempfmt - 1);

if (data[loc + 6] != 0x08 && data[loc + 7] != 0x60)
return false;

tempfmt = data[loc + 11] & 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 12) >> 2;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 48) >> 4;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 11] & 192) >> 6;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = data[loc + 10] & 3;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 12) >> 2;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 48) >> 4;
if (tempfmt)
fmt.push_back(tempfmt - 1);
tempfmt = (data[loc + 10] & 192) >> 6;
if (tempfmt)
fmt.push_back(tempfmt - 1);

if (data[loc + 16] != 0x08 && data[loc + 17] != 0x00)
return false;

colorfmt = data[loc + 20] & 3;
normalfmt = (data[loc + 20] & 12) >> 2;
uvfmt = (data[loc + 20] & 240) >> 4;

// find the start of the data
loc += 40;
while (data[loc] == 0) {
loc++;
}

// read data
bool reading = true;
do {
char type = data[loc];
loc++;
switch (type) {
case 0x30:
loc += 4;
break;
case 0x20:
loc += 4;
break;
case 0x28:
loc += 4;
break;
case 0x98: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
int length;
for (int i = 0; i < count - 2; i++) {
Vertex p1, p2, p3;
if (i % 2) {
p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc -= length;
} else {
p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc -= length;
}
Triangle tri(p1, p2, p3);
group->AddTriangle(tri);
}
loc += length * 2;
} else {
TriangleStrip strip;
for (int i = 0; i < count; i++) {
int length;
strip.Add(loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length));
loc += length;
}
strip.Lock();
group->AddTriangleStrip(strip);
}
}
break;
case 0x90: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

for (int i = 0; i < count; i += 3) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Triangle tri(p1, p2, p3);
group->AddTriangle(tri);
}
}
break;
case 0xA0: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
int length;
Vertex origin = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;

for (int i = 1; i < count - 1; i++) {

Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
Triangle tri(origin, p1, p2);
group->AddTriangle(tri);
}
loc += length;
} else {
int length;
Vertex origin = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
TriangleFan fan(origin);
for (int i = 1; i < count; i++) {

fan.Add(loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length));
loc += length;
}
fan.Lock();
group->AddTriangleFan(fan);
}
}
break;
case 0x80: {
uint16_t count = BigUInt16(data, loc);
loc += 2;

if (options & LO_CONV_TO_TRIS) {
for (int i = 0; i < count; i += 4) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p4 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Triangle tri1(p1, p2, p3);
Triangle tri2(p1, p3, p4);
group->AddTriangle(tri1);
group->AddTriangle(tri2);
}
} else {
for (int i = 0; i < count; i += 4) {
int length;
Vertex p1 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p2 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p3 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Vertex p4 = loadVertex(data, loc, fmt, normalfmt, colorfmt,
unknownfmt, uvfmt, length);
loc += length;
Quad quad(p1, p2, p3, p4);
group->AddQuad(quad);
}
}
}
break;
case 0x00:
reading = false;
break;
default:
return false;
}
} while (reading);

group->SetVertex(vertexid, &vertexGroups[vertexid]);

if (normalid != 0xFFFF)
group->SetNormal(normalid, &normalGroups[normalid]);

if (colorid != 0xFFFF)
group->SetColor(colorid, &colorGroups[colorid]);

for (int i = 0; i < 8; i++) {
if (texcoordid[i] != 0xFFFF) {
group->AddUV(texcoordid[i], &uvGroups[texcoordid[i]]);
}
}

group->Lock();

return true;
}

Vertex MDL0File::loadVertex(const char* data, int offset, std::vector<int> fmt,
bool hasNormal, bool hasColor, int unknown, int uv, int& outLength) {
uint16_t vert = 0;
uint16_t norm = 0;
uint16_t color = 0;
uint16_t uvs[8];

int length = 0;

// assuming all unknowns are one byte long for now.
length += unknown;

if (fmt[0] == 1) {
vert = (unsigned char) data[offset + length];
length += 1;
} else {
vert = BigUInt16(data, offset + length);
length += 2;
}

if (hasNormal) {
if (fmt[1] == 1) {
norm = (unsigned char) data[offset + length];
length += 1;
} else {
norm = BigUInt16(data, offset + length);
length += 2;
}
}

if (hasColor) {
if (fmt[1 + hasNormal] == 1) {
color = (unsigned char) data[offset + length];
length += 1;
} else {
color = BigUInt16(data, offset + length);
length += 2;
}
}

for (int i = 0; i < uv; i++) {
if (fmt[1 + hasNormal + hasColor + i] == 1) {
uvs[i] = (unsigned char) data[offset + length];
length += 1;
} else {
uvs[i] = BigUInt16(data, offset + length);
length += 2;
}
}

Vertex outvert;
outvert.Set(vert, norm, color, uvs, uv);

outLength = length;

return outvert;
}








using namespace std;

class COLLADAExport {
public:
COLLADAExport();
virtual ~COLLADAExport();

bool Export(MDL0File* mdl0, const char* destfilename);

private:
void addMetadata(domCOLLADA* root);
void addLibraryGeometry(domCOLLADA* root, MDL0File* mdl0);
void addPositionArray(daeElement* mesh, Vec3Group* group, string geomName);
void addTexcoordArray(daeElement* mesh, Vec2Group* group, string geomName);
void addTriangleStrips(daeElement* mesh, PolyGroup* group, string name);
void addTriangleFans(daeElement* mesh, PolyGroup* group, string name);
void addTriangles(daeElement* mesh, PolyGroup* group, string name);
void addQuads(daeElement* mesh, PolyGroup* group, string name);
void addInputs(daeElement* parent, PolyGroup* group, string name);
string intToString(int num);


};







COLLADAExport::COLLADAExport() {
// TODO Auto-generated constructor stub

}

COLLADAExport::~COLLADAExport() {
// TODO Auto-generated destructor stub
}

bool COLLADAExport::Export(MDL0File* mdl0, const char* destfilename) {
DAE dae;

domCOLLADA* root = dae.add(destfilename);

if (root == NULL)
return false;

addMetadata(root);

addLibraryGeometry(root, mdl0);

dae.writeAll();

return true;
}

void COLLADAExport::addMetadata(domCOLLADA* root) {
daeElement* asset = root->add("asset");

// add contributer
daeElement* contributor = asset->add("contributor");
//daeElement* author = asset->add("author");
daeElement* authoring_tool = contributor->add("authoring_tool");
authoring_tool->setCharData("MDL0 to COLLADA converter");
daeElement* comments = contributor->add("comments");
comments->setCharData(
"This file was created by the mdl0converter, written by William Hahne. The copyright of this file belongs to the creator of the original input file.");

// get the current time and then format it correctly for XML
ostringstream strm;
time_t t = time(NULL);
struct tm* lt = localtime(&t);
strm << lt->tm_year + 1900 << "-" << lt->tm_mon << "-" << lt->tm_mday
<< "T" << lt->tm_hour << ":" << lt->tm_min << ":" << lt->tm_sec
<< "Z";
string current_time = strm.str();

// set created and modified time
daeElement* created = asset->add("created");
created->setCharData(current_time);
daeElement* modified = asset->add("modified");
modified->setCharData(current_time);
}

void COLLADAExport::addLibraryGeometry(domCOLLADA* root, MDL0File* mdl0) {
daeElement* library_geometries = root->add("library_geometries");

for (int i = 0; i < mdl0->PolygonGroupCount(); i++) {
PolyGroup* group = mdl0->GetPolygonGroup(i);
daeElement* geometry = library_geometries->add("geometry");

ostringstream strm;
strm << "Polygon" << i;
string name = strm.str();

geometry->setAttribute("id", name.c_str());

daeElement* mesh = geometry->add("mesh");

addPositionArray(mesh, group->VertexGroupPtr(), name + "-position");
addPositionArray(mesh, group->NormalGroupPtr(), name + "-normal");
for (int i = 0; i < group->UVGroupCount(); i++)
addTexcoordArray(mesh, group->UVGroupPtr(i), name + "-texcoord"
+ intToString(i));

daeElement* vertices = mesh->add("vertices");
string vertName(name + "-vertex");
vertices->setAttribute("id", vertName.c_str());
daeElement* input = vertices->add("input");
input->setAttribute("semantic", "POSITION");
string sourceName("#" + name + "-position");
input->setAttribute("source", sourceName.c_str());

if (group->TriangleStripCount() > 0)
addTriangleStrips(mesh, group, name);

if (group->TriangleFanCount() > 0)
addTriangleFans(mesh, group, name);

if (group->TriangleCount() > 0)
addTriangles(mesh, group, name);
}

// temporary until I (hopefully) find a better solution
daeElement* visual_scene = root->add("library_visual_scenes visual_scene");
visual_scene->setAttribute("id", "testscene");
for (int i = 0; i < mdl0->PolygonGroupCount(); i++) {
daeElement* instance_geometry = visual_scene->add(
"node instance_geometry");
string name("#Polygon" + intToString(i));
instance_geometry->setAttribute("url", name.c_str());
}

daeElement* instance_visual_scene =
root->add("scene instance_visual_scene");
instance_visual_scene->setAttribute("url", "#testscene");
}

void COLLADAExport::addPositionArray(daeElement* mesh, Vec3Group* group,
string posName) {
daeElement* source = mesh->add("source");
source->setAttribute("id", posName.c_str());

daeElement* float_array = source->add("float_array");
string arrayPosName(posName + "-array");
float_array->setAttribute("id", arrayPosName.c_str());
float_array->setAttribute("count", intToString(group->size() * 3).c_str());

ostringstream strm;
for (uint i = 0; i < group->size(); i++) {
Vec3 vec = (*group)[i];
strm << -vec.X() << " " << vec.Y() << " " << vec.Z() << "\n";
}
float_array->setCharData(strm.str());

daeElement* accessor = source->add("technique_common accessor");

string arrayPosSourceName("#" + arrayPosName);
accessor->setAttribute("source", arrayPosSourceName.c_str());
accessor->setAttribute("count", intToString(group->size()).c_str());
accessor->setAttribute("stride", "3");
daeElement* paramX = accessor->add("param");
paramX->setAttribute("name", "X");
paramX->setAttribute("type", "float");
daeElement* paramY = accessor->add("param");
paramY->setAttribute("name", "Y");
paramY->setAttribute("type", "float");
daeElement* paramZ = accessor->add("param");
paramZ->setAttribute("name", "Z");
paramZ->setAttribute("type", "float");

}

void COLLADAExport::addTexcoordArray(daeElement* mesh, Vec2Group* group,
string posName) {
daeElement* source = mesh->add("source");
source->setAttribute("id", posName.c_str());

daeElement* float_array = source->add("float_array");
string arrayPosName(posName + "-array");
float_array->setAttribute("id", arrayPosName.c_str());
float_array->setAttribute("count", intToString(group->size() * 2).c_str());

ostringstream strm;
for (uint i = 0; i < group->size(); i++) {
Vec2 vec = (*group)[i];
strm << vec.U() << " " << vec.V() << " ";
}
float_array->setCharData(strm.str());

daeElement* accessor = source->add("technique_common accessor");

string arrayPosSourceName("#" + arrayPosName);
accessor->setAttribute("source", arrayPosSourceName.c_str());
accessor->setAttribute("count", intToString(group->size()).c_str());
accessor->setAttribute("stride", "2");
daeElement* paramU = accessor->add("param");
paramU->setAttribute("name", "U");
paramU->setAttribute("type", "float");
daeElement* paramV = accessor->add("param");
paramV->setAttribute("name", "V");
paramV->setAttribute("type", "float");

}

void COLLADAExport::addTriangleStrips(daeElement* mesh, PolyGroup* group,
string name) {
daeElement* tristrips = mesh->add("tristrips");
tristrips->setAttribute("count",
intToString(group->TriangleStripCount()).c_str());

addInputs(tristrips, group, name);

for (uint i = 0; i < group->TriangleStripCount(); i++) {
daeElement* p = tristrips->add("p");

TriangleStrip strip = group->GetTriangleStrip(i);

ostringstream strm;
for (uint j = 0; j < strip.Count(); j++) {
Vertex vert = strip[j];
if (vert.GetVertex() >= group->VertexGroupPtr()->size())
std::cout << "WARNING: Tristrip vertex out of range in "
<< name << endl;
if (vert.GetNormal() >= group->NormalGroupPtr()->size())
std::cout << "WARNING: Tristrip normal out of range in "
<< name << endl;
strm << vert.GetVertex() << " " << vert.GetNormal() << "  ";

for (int k = 0; k < vert.UVCount(); k++) {
strm << vert.GetUV(k) << " ";
}
}
p->setCharData(strm.str());
}
}
void COLLADAExport::addTriangleFans(daeElement* mesh, PolyGroup* group,
string name) {
daeElement* trifans = mesh->add("trifans");
trifans->setAttribute("count",
intToString(group->TriangleFanCount()).c_str());

addInputs(trifans, group, name);

for (uint i = 0; i < group->TriangleFanCount(); i++) {
daeElement* p = trifans->add("p");

TriangleFan fan = group->GetTriangleFan(i);

ostringstream strm;
Vertex origin = fan.GetOriginVertex();
strm << origin.GetVertex() << " " << origin.GetNormal() << "  ";
for (uint j = 0; j < fan.Count(); j++) {
Vertex vert = fan[j];
if (vert.GetVertex() >= group->VertexGroupPtr()->size())
std::cout << "WARNING: Triangle Fan vertex out of range in "
<< name << endl;
if (vert.GetNormal() >= group->NormalGroupPtr()->size())
std::cout << "WARNING: Triangle Fan normal out of range in "
<< name << endl;
strm << vert.GetVertex() << " " << vert.GetNormal() << " ";

for (int k = 0; k < vert.UVCount(); k++) {
strm << vert.GetUV(k) << " ";
}
}
p->setCharData(strm.str());
}
}
void COLLADAExport::addTriangles(daeElement* mesh, PolyGroup* group,
string name) {
daeElement* tris = mesh->add("triangles");
tris->setAttribute("count", intToString(group->TriangleCount()).c_str());

addInputs(tris, group, name);

daeElement* p = tris->add("p");
ostringstream strm;
for (uint i = 0; i < group->TriangleCount(); i++) {
Triangle tri = group->GetTriangle(i);

for (int j = 0; j < 3; j++) {
Vertex vert = tri[j];
if (vert.GetVertex() >= group->VertexGroupPtr()->size())
std::cout << "TRIANGLE WARNING: Vertex out of range in "
<< name << endl;
if (vert.GetNormal() >= group->NormalGroupPtr()->size())
std::cout << "TRIANGLE WARNING: Normal out of range in "
<< name << endl;
strm << vert.GetVertex() << " " << vert.GetNormal() << " ";

for (int k = 0; k < vert.UVCount(); k++) {
strm << vert.GetUV(k) << " ";
}
}
strm << "\n";
}
p->setCharData(strm.str());
}
void COLLADAExport::addQuads(daeElement* mesh, PolyGroup* group, string name) {

}

void COLLADAExport::addInputs(daeElement* parent, PolyGroup* group, string name) {
daeElement* inputVert = parent->add("input");
inputVert->setAttribute("semantic", "VERTEX");
string vertSourceName("#" + name + "-vertex");
inputVert->setAttribute("source", vertSourceName.c_str());
inputVert->setAttribute("offset", "0");
daeElement* inputNorm = parent->add("input");
inputNorm->setAttribute("semantic", "NORMAL");
string normSourceName("#" + name + "-normal");
inputNorm->setAttribute("source", normSourceName.c_str());
inputNorm->setAttribute("offset", "1");

for (int i = 0; i < group->UVGroupCount(); i++) {
daeElement* inputTex = parent->add("input");
inputTex->setAttribute("semantic", "TEXCOORD");
string texSourceName("#" + name + "-texcoord" + intToString(i));
inputTex->setAttribute("source", texSourceName.c_str());
inputTex->setAttribute("offset", intToString(2 + i).c_str());
inputTex->setAttribute("set", "0");
}
}

string COLLADAExport::intToString(int num) {
ostringstream strm;
strm << num;
return strm.str();
}










using namespace std;

void printUsage() {
cout << "Usage:" << endl;
cout << "mdl0converter [-t] input_file output_file" << endl << endl;
cout << "Options:" << endl;
cout << "   -t    Convert all triangle strips, triangle fans, and quads to triangles." << endl << endl;
cout << "Copyright (C) 2008 William Hahne" << endl;
}

void printCredits() {
// todo: add credits
}

int main(int argc, char *argv[]) {
char* inputfile = NULL;
char* outputfile = NULL;
uint opts = 0;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 't':
opts |= LO_CONV_TO_TRIS;
break;
default:
cout << "Invalid option: " << argv[i] << endl;
printUsage();
return 0;
}
} else {
if (inputfile == NULL) {
inputfile = argv[i];
}
else if (inputfile != NULL && outputfile == NULL) {
outputfile = argv[i];
}
}
}

if (inputfile == NULL || outputfile == NULL) {
cout << "Not enough arguments." << endl;
printUsage();
return 0;
}

ifstream f;
f.open(inputfile, ios::binary | ios::in);
if (!f.good() || !f.is_open()) {
cout << "Error opening file." << endl << endl;
printUsage();
return 0;
}
f.seekg(0, ios::beg);
int begin = f.tellg();
f.seekg(0, ios::end);
int size = (int) f.tellg() - begin;

f.seekg(0, ios::beg);
char* data = new char[size];
f.read(data, size);

MDL0File file;
file.Load(data, size, opts);

// convert to collada
COLLADAExport daeExport;
outputfile = inputfile + ".DAE"
if (!daeExport.Export(&file, outputfile)) {
cout << "Error writing output file." << endl << endl;
printUsage();
return 0;
}

cout << "Success" << endl;

return 0;
}