1. #include <cstdint>
2. #include <vector>
3. #include <iostream>
4. #include <cstdio>
6. template<typename T>
7. struct M2Array
8. {
9. uint32_t number;
10. uint32_t offset_elements;
11. T* get (void* data) const
12. {
13. return (T*)((char*)data + offset_elements);
14. }
15. };
16. template<typename T>
17. struct M2Track
18. {
19. uint16_t interpolation_type;
20. uint16_t global_sequence;
21. M2Array<M2Array<uint32_t>> timestamps;
22. M2Array<M2Array<T>> values;
23. };
24. struct C3Vector
25. {
26. float x;
27. float y;
28. float z;
29. C3Vector (float _x, float _y, float _z)
30. : x (_x), y (_y), z (_z)
31. {}
32. };
33. struct M2CompQuat
34. {
35. uint16_t val[4]; // maps to C4Quaternion. See Quaternion values and 2.x.
36. };
37. struct M2CompBone
38. {
39. int32_t key_bone_id; // Back-reference to the key bone lookup table. -1 if this is no key bone.
40. enum
41. {
42. spherical_billboard = 0x8,
43. cylindrical_billboard = 0x40,
44. transformed = 0x200,
45. kinematic_bone = 0x400, // MoP+: allow physics to influence this bone
46. helmet_anim_scaled = 0x1000, // set blend_modificator to helmetAnimScalingRec.m_amount for this bone
47. };
48. uint32_t flags;
49. int16_t parent_bone; // Parent bone ID or -1 if there is none.
50. uint16_t submesh_id; // Mesh part ID
51. uint16_t _unknown[2];
52. M2Track<C3Vector> translation;
53. M2Track<M2CompQuat> rotation; // compressed values, see Quaternion values and 2.x. Default is (32767,32767,32767,65535) == (0,0,0,1) == identity
54. M2Track<C3Vector> scale;
55. C3Vector pivot; // The pivot point of that bone.
56. };
58. template<typename T>
59. struct m2_array_iter
60. {
61. M2Array<T>& _array;
62. void* _data;
63. m2_array_iter (M2Array<T>& array, void* data)
64. : _array (array)
65. , _data (data)
66. {}
67. using value_type = T&;
68. T* begin() const { return _array.get (_data); }
69. T* end() const { return _array.get (_data) + _array.number; }
70. };
71. template<typename T>
72. m2_array_iter<T> iter (M2Array<T>& array, void* data)
73. {
74. return m2_array_iter<T> (array, data);
75. }
76. struct m2_header_partially
77. {
78. uint32_t magic;
79. uint32_t version;
80. M2Array<char> name;
81. uint32_t global_flags;
82. M2Array<uint32_t> global_sequences;
83. M2Array<void> animations;
84. M2Array<void> animation_lookup;
85. M2Array<M2CompBone> bones;
86. // ...
87. };
89. namespace key_bone { enum
90. {
91. ArmL,
92. ArmR,
93. ShoulderL,
94. ShoulderR,
95. SpineLow,
96. Waist,
97. Head,
98. Jaw,
99. IndexFingerR,
100. MiddleFingerR,
101. PinkyFingerR,
102. RingFingerR,
103. ThumbR,
104. IndexFingerL,
105. MiddleFingerL,
106. PinkyFingerL,
107. RingFingerL,
108. ThumbL,
109. BTH,
110. CSR,
111. CSL,
112. _Breath,
113. _Name,
114. _NameMount,
115. CHD,
116. CCH,
117. Root,
118. Wheel1,
119. Wheel2,
120. Wheel3,
121. Wheel4,
122. Wheel5,
123. Wheel6,
124. Wheel7,
125. Wheel8,
126. };}
128. struct IffChunk
129. {
130. uint32_t magic;
131. uint32_t size;
132. char data[];
133. };
135. struct fake_animation_block_data_with_one_c3vector
136. {
137. uint32_t timestamp;
138. C3Vector value;
139. M2Array<uint32_t> timestamps;
140. M2Array<C3Vector> values;
141. fake_animation_block_data_with_one_c3vector (float scale_factor, uint32_t base_offset, uint32_t* timestamps_offset, uint32_t* values_offset)
142. : timestamp (0)
143. , value (scale_factor, scale_factor, scale_factor)
144. {
145. timestamps.number = 1;
146. timestamps.offset_elements = base_offset + offsetof (fake_animation_block_data_with_one_c3vector, timestamp);
147. values.number = 1;
148. values.offset_elements = base_offset + offsetof (fake_animation_block_data_with_one_c3vector, value);
149. *timestamps_offset = base_offset + offsetof (fake_animation_block_data_with_one_c3vector, timestamps);
150. *values_offset = base_offset + offsetof (fake_animation_block_data_with_one_c3vector, values);
151. }
152. };
154. namespace
155. {
156. void* find_base_file (void* data)
157. {
158. IffChunk* chunk ((IffChunk*)data);
159. if (chunk->magic == '02DM')
160. {
161. return chunk;
162. }
163. else
164. {
165. while (chunk->magic != '12DM')
166. {
167. chunk = (IffChunk*)(chunk->data + chunk->size);
168. }
169. return chunk->data;
170. }
171. }
172. }
174. namespace sys
175. {
176. FILE* fopen (char const* name, char const* mode)
177. {
178. auto r (::fopen (name, mode));
179. if (!r) { throw std::runtime_error ("fopen (" + std::string (name) + ")"); }
180. return r;
181. }
182. void fclose (FILE* file)
183. {
184. if (::fclose (file)) throw std::runtime_error ("fclose");
185. }
186. void fread (void* ptr, size_t size, size_t count, FILE* file)
187. {
188. auto r (::fread (ptr, size, count, file));
189. if (r != count) { throw std::runtime_error ("fread"); }
190. }
191. void fwrite (void* ptr, size_t size, size_t count, FILE* file)
192. {
193. auto r (::fwrite (ptr, size, count, file));
194. if (r != count) { throw std::runtime_error ("fwrite"); }
195. }
196. void fseek (FILE* file, size_t offset, int mode)
197. {
198. if (::fseek (file, offset, mode)) throw std::runtime_error ("fseek");
199. }
200. }
202. int main (int argc, char** argv)
203. {
204. bool is_legion (true);
205. float scale_factor (2.0f);
207. for (size_t i (1); i < argc; ++i)
208. try
209. {
210. FILE* file (sys::fopen (argv[i], "rb+"));
211. sys::fseek (file, 0, SEEK_END);
212. std::size_t file_size (ftell (file));
213. std::vector<char> file_data (file_size);
214. sys::fseek (file, 0, SEEK_SET);
215. sys::fread (file_data.data(), file_data.size(), 1, file);
216. sys::fclose (file);
218. uint32_t fake_timestamps_offset;
219. uint32_t fake_values_offset;
220. {
221. uint32_t fake_animation_block_data_with_one_c3vector_offset_in_file (0);
222. uint32_t fake_animation_block_data_with_one_c3vector_offset_in_base_file (0);
224. IffChunk* chunk ((IffChunk*)file_data.data());
225. if (chunk->magic == '02DM')
226. {
227. fake_animation_block_data_with_one_c3vector_offset_in_file = file_size;
228. fake_animation_block_data_with_one_c3vector_offset_in_base_file = file_size;
229. }
230. else
231. {
232. while (chunk->magic != '12DM')
233. {
234. chunk = (IffChunk*)(chunk->data + chunk->size);
235. }
236. fake_animation_block_data_with_one_c3vector_offset_in_file = chunk->data + chunk->size - (char*)(file_data.data());
237. fake_animation_block_data_with_one_c3vector_offset_in_base_file = chunk->size;
238. chunk->size += sizeof (fake_animation_block_data_with_one_c3vector);
239. }
240. file_data.insert ( file_data.begin() + fake_animation_block_data_with_one_c3vector_offset_in_file
241. , sizeof (fake_animation_block_data_with_one_c3vector)
242. , 0
243. );
245. new (file_data.data() + fake_animation_block_data_with_one_c3vector_offset_in_file) fake_animation_block_data_with_one_c3vector
246. ( scale_factor
247. , fake_animation_block_data_with_one_c3vector_offset_in_base_file
248. , &fake_timestamps_offset
249. , &fake_values_offset
250. );
251. }
253. void* const data (find_base_file (file_data.data()));
254. m2_header_partially* header ((m2_header_partially*)data);
256. for (M2CompBone& bone : iter (header->bones, data))
257. {
258. if (bone.key_bone_id == key_bone::Head)
259. {
260. if (bone.scale.values.number != 0)
261. {
262. throw std::runtime_error ("appears broken, thus disabled");
263. for (auto& values : iter (bone.scale.values, data))
264. {
265. for (C3Vector& value : iter (values, data))
266. {
267. value.x *= scale_factor;
268. value.y *= scale_factor;
269. value.z *= scale_factor;
270. }
271. }
272. }
273. else
274. {
275. bone.scale.timestamps.number = 1;
276. bone.scale.timestamps.offset_elements = fake_timestamps_offset;
277. bone.scale.values.number = 1;
278. bone.scale.values.offset_elements = fake_values_offset;
279. }
280. }
281. }
283. file = sys::fopen (argv[i], "w+");
284. sys::fwrite (file_data.data(), file_data.size(), 1, file);
285. sys::fclose (file);
286. }
287. catch (std::exception const& ex)
288. {
289. std::cerr << argv[i] << ": " << ex.what() << std::endl;
290. }
292. return 0;
293. }