Dme.bt

// 010 Editor Template for Forgelight DME files
// from Planetside 2
// synide@rocketmail.com
// July, 2018


typedef struct
{
	ubyte					x;
	ubyte					y;
	ubyte					z;
	ubyte					w;
} ubyte4n_t;

typedef struct
{
	ubyte					a;
	ubyte					r;
	ubyte					g;
	ubyte					b;
} d3dcolor_t;

typedef struct
{
	float m00;
	float m01;
	float m02;
} xfrm_row_0_t;

typedef struct
{
	float m10;
	float m11;
	float m12;
} xfrm_row_1_t;

typedef struct
{
	float m20;
	float m21;
	float m22;
} xfrm_row_2_t;

typedef struct
{
	float m30;
	float m31;
	float m32;
} xfrm_row_3_t;

////////////////////////
//		USAGE TYPES
////////////////////////

typedef struct
{
	float x<name="X">;
	float y<name="Y">;
	float z<name="Z">;
} position_t<read=fn_Read_position_t>;

typedef struct
{
	hfloat					u<name="U">;
	hfloat					v<name="V">;
} texcoord_t;

typedef struct
{
	ubyte					a;
	ubyte					r;
	ubyte					g;
	ubyte					b;
} color_t;

typedef struct
{
	ubyte					x;
	ubyte					y;
	ubyte					z;
	ubyte					w;
} tangent_t;

typedef struct
{
	ubyte					x;
	ubyte					y;
	ubyte					z;
	ubyte					w;
} binormal_t;

typedef struct
{
	ubyte4n_t				blendweight<name="BlendWeight", read=fn_Read_BlendWeight>;
} blendweight_t;

typedef struct
{
	d3dcolor_t				blendindices<name="BlendIndices", read=fn_Read_BlendIndices>;
} blendindices_t;

typedef struct
{
	position_t min<name="min">;
	position_t max<name="max">;
} aabb_t<read=fn_Read_AABB>;

typedef struct
{
	byte											magic[4]<name="Magic", fgcolor=cRed>;
	uint											version<name="Version">;
	uint											dmat_length<name="DMAT Length">;
} header_t;

typedef struct
{
	string										texture<name="Texture">;
} texture_t;

typedef struct
{
	uint											semantic_hash;
	uint											d3dxparameter_class;
	uint											d3dxparameter_type;
	uint											data_length;
	byte											data[data_length];
} material_parameter_t;

typedef struct
{
	uint											name_hash<name="Name Hash">;
	uint											materials_length<name="Materials Length">;
	uint											material_definition_hash<name="Material Definition Hash">;
	uint											parameter_count<name="Parameter Count">;
	material_parameter_t			parameters[parameter_count]<name="Parameters", optimize=false>;
} material_t;

typedef struct
{
	byte											magic[4]<name="Magic", fgcolor=cRed>;
	uint											version<name="Version">;
	uint											textures_length<name="Textures Length">;
  local uint tx_start_offset = FTell();
  while(FTell() < tx_start_offset + textures_length)
  {
    texture_t								texture<name="Texture">;
  };
	uint											material_count<name="Material Count">;
	material_t								materials[material_count]<name="Materials", optimize=false>;
} dmat_t;

///////////////////////////////////////////////////////////////////////////////////////////
//
//					VERTEX STREAM LAYOUT STURCTURES
//
///////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////
//Null Layout
typedef struct
{
	position_t				position<name="Position">;
} null_layout_t;

///////////////////////////////////////////////////////////////////////////////////////////
//Position Layout
typedef struct
{
	position_t				position<name="Position">;
} position_layout_t;

///////////////////////////////////////////////////////////////////////////////////////////
//POS_TEX Layout
typedef struct
{
	position_t				position<name="Position">;
	texcoord_t				texcoord<name="Texcoord">;
} pos_tex_layout_t;

///////////////////////////////////////////////////////////////////////////////////////////
//Structure Layout
typedef struct
{
	position_t				position<name="Position">;
} structure_layout_stream_0_t;

typedef struct
{
	tangent_t					tangent<name="Tangent">;
	binormal_t				binormal<name="Binormal">;
	texcoord_t				texcoord0<name="Texcoord0">;
	texcoord_t				texcoord1<name="Texcoord1">;
	texcoord_t				texcoord2<name="Texcoord2">;
} structure_layout_stream_1_t;

///////////////////////////////////////////////////////////////////////////////////////////
//Character Layout
typedef struct
{
	position_t					position<name="Position">;
	blendweight_t				blendweight<name="BlendWeight">;
	blendindices_t			blendindices<name="BlendIndices">;
} character_layout_stream_0_t;

typedef struct
{
	tangent_t						tangent<name="Tangent">;
	binormal_t					binormal<name="Binormal">;
	texcoord_t					uv0<name="UV0">;
	texcoord_t					uv1<name="UV1">;
	texcoord_t					uv2<name="UV2">;
} character_layout_stream_1_t;

///////////////////////////////////////////////////////////////////////////////////////////
//Vehicle Layout
typedef struct
{
	position_t					position<name="Position">;
} vehicle_layout_stream_0_t;

typedef struct
{
	tangent_t						tangent<name="Tangent">;
	binormal_t					binormal<name="Binormal">;
	texcoord_t					uv0<name="UV0">;
	texcoord_t					uv1<name="UV1">;
	color_t							color<name="Color">;
	texcoord_t					uv2<name="UV2">;
} vehicle_layout_stream_1_t;

///////////////////////////////////////////////////////////////////////////////////////////
//BumpRigid Layout
typedef struct
{
	position_t					position<name="Position">;
} bumprigid_layout_stream_0_t;

typedef struct
{
	tangent_t						tangent<name="Tangent">;
	binormal_t					binormal<name="Binormal">;
	texcoord_t					uv0<name="UV0">;
} bumprigid_layout_stream_1_t;











typedef struct
{
	ushort					vert_index_0<name="Vert_0">;
	ushort					vert_index_1<name="Vert_1">;
	ushort					vert_index_2<name="Vert_2">;
} triangle_t;

typedef struct
{
//	uint						unknown_1<name="Unknown_1">;
	uint						bone_start<name="Bone Start">;
	uint						bone_count<name="Bone Count">;
	uint						delta<name="Delta">;
	uint						unknown_2<name="Unknown_2">;
	uint						vertex_offset<name="Vertex Offset">;
	uint						vertex_count<name="Vertex Count">;
	uint						index_offset<name="Index Offset">;
	uint						index_count<name="Index Count">;
} drawcall_t;

typedef struct
{
	ushort					bone_index<name="Bone Index">;
	ushort					global_index<name="Global Index">;
} bone_map_entry_t;

typedef struct
{
	xfrm_row_0_t				row0<name="Row_0">;
	xfrm_row_1_t				row1<name="Row_1">;
	xfrm_row_2_t				row2<name="Row_2">;
	xfrm_row_3_t				row3<name="Row_3">;
} transform_t;


typedef struct
{
	
} mesh3_t;

typedef struct
{
	uint													material_index<name="Material Index">;
	uint													drawcall_count<name="Drawcall Count">;
	uint													bone_transform_count<name="Bone Transform Count">;
	uint													unknown<name="Unknown">;
	uint													vertex_stream_count<name="Vertex Stream Count">;
	uint													index_size<name="Index Size">;
	uint													index_count<name="Index Count">;
	uint													vertex_count<name="Vertex Count">;

	local uint mat_def_hash = dmat.materials[material_index].material_definition_hash;
	
	switch (mat_def_hash)
	{
		case 2201291178: //Character
		{
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				character_layout_stream_0_t				points[vertex_count]<name="Points", optimize=false>;
			} character_stream_0_t;
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				character_layout_stream_1_t				points[vertex_count]<name="Points", optimize=false>;
			} character_stream_1_t;

			character_stream_0_t stream0<name="Stream0">;
			character_stream_1_t stream1<name="Stream1">;

			break;
		}
		///////////////////////////////////////////////////////////////////////////////////////////
		case 221567923: //Vehicle
		{
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				vehicle_layout_stream_0_t					points[vertex_count]<name="Points", optimize=false>;
			} vehicle_stream_0_t;
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				vehicle_layout_stream_1_t					points[vertex_count]<name="Points", optimize=false>;
			} vehicle_stream_1_t;

			vehicle_stream_0_t stream0<name="Stream0">;
			vehicle_stream_1_t stream1<name="Stream1">;

			break;
		}
		///////////////////////////////////////////////////////////////////////////////////////////
		case 3731096925: //Structure
		{
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				structure_layout_stream_0_t				points[vertex_count]<name="Points", optimize=false>;
			} structure_stream_0_t;
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				structure_layout_stream_1_t				points[vertex_count]<name="Points", optimize=false>;
			} structure_stream_1_t;

			structure_stream_0_t stream0<name="Stream0">;
			structure_stream_1_t stream1<name="Stream1">;

			break;
		}
		case 1354477071: //BumpRigid
		{
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				bumprigid_layout_stream_0_t				points[vertex_count]<name="Points", optimize=false>;
			} bumprigid_stream_0_t;
			typedef struct
			{
				uint															bytes_per_vertex<name="BytesPerVertex">;
				bumprigid_layout_stream_1_t				points[vertex_count]<name="Points", optimize=false>;
			} bumprigid_stream_1_t;

			bumprigid_stream_0_t stream0<name="Stream0">;
			bumprigid_stream_1_t stream1<name="Stream1">;

			break;
		}
		default:
		{
			break;
		}
	}

	typedef struct
	{
		triangle_t									faces[index_count / 3]<name="Triangles">;
	} triangles_t;
	
	triangles_t										faces<name="Faces">;
/*
	uint													draw_call_count<name="Drawcall Count">;
	//uint													unknown_2<name="Unknown_2">;
	FSkip(4);
	drawcall_t										drawcall<name="Drawcall">;
	uint													bone_map_entry_count<name="Bonemap Entry Count">;
	
	typedef struct
	{
		bone_map_entry_t						bonemap[bone_map_entry_count]<name="Bonemap", optimize=false>;
	} bone_maps_t;
	
	bone_maps_t										bonemaps<name="Bonemaps">;
	uint													transform_count<name="Transform Count">;
	transform_t										transforms[transform_count]<name="Transforms">;
	
	typedef struct
	{
		aabb_t											transform_bbox[transform_count]<name="Transform BBox">;
	} transform_bboxs_t;
	
	transform_bboxs_t						transform_bboxs<name="Transform BBox's">;
	
	typedef struct
	{
		uint											bone_name_hash[transform_count]<name="Bone Name Hash">;
	} bone_name_hash_t;
	
	bone_name_hash_t						bone_name_hashs<name="Bone Name Hash's">;
*/
} mesh4_t;

typedef struct
{
	aabb_t																											aabb<name="AABB">;
	uint																												mesh_count<name="Mesh Count">;
	mesh4_t																											mesh[mesh_count]<name="Mesh", optimize=false>;
} model4_t;








///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

uint fn_Jenkins_Hash(string s, int upper)
{
	if (Strlen(s) == 0)
		return 0;
	if (upper)
		s = ToUpper(s);

	int hash = 0;
	int len = Strlen(s);
	for (i = 0; i < len; i++)
	{
		hash += s[i];
		hash += (hash << 10);
		hash ^= (hash >> 6);
	}
	hash += (hash << 3);
	hash ^= (hash >> 11);
	hash += (hash << 15);
	return (unsigned int)hash;
}

string fn_Read_AABB(aabb_t &aabb)
{
	string s;
	SPrintf(s, "min_xyz: %6.2f, %6.2f, %6.2f | max_xyz: %6.2f, %6.2f, %6.2f", aabb.min.x, aabb.min.y, aabb.min.z, aabb.max.x, aabb.max.y, aabb.max.z);
	return s;
}

string fn_Read_position_t(position_t &pos)
{
	string s;
	SPrintf(s, "xyz: %6.6f, %6.6f, %6.6f", pos.x, pos.y, pos.z);
	return s;
}

string fn_Read_BlendWeight(ubyte4n_t &weights)
{
	string s;
	float x = (float)weights.x / 255.0f;
	float y = (float)weights.y / 255.0f;
	float z = (float)weights.z / 255.0f;
	float w = (float)weights.w / 255.0f;
	return SPrintf(s, "xyzw: %6.6f, %6.6f, %6.6f, %6.6f", x, y, z, w);
}

string fn_Read_BlendIndices(d3dcolor_t &indices)
{
	string s;
	return SPrintf(s, "%u, %u, %u, %u", indices.a, indices.r, indices.g, indices.b);
}


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

LittleEndian();






header_t												header<name="Header">;
dmat_t													dmat<name="Dmat">;
if (header.version == 3)
{
	//Do nothing at this time
}
else if (header.version == 4)
{
	model4_t											model<name="Model">;
}
else
{
	Warning( "Only able to process version 3 & 4 types of DME files." );
	return -1;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////