Rigs of Rods 2023.09
Soft-body Physics Simulation
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Loading...
Searching...
No Matches
RigDef_Serializer.cpp
Go to the documentation of this file.
1/*
2 This source file is part of Rigs of Rods
3 Copyright 2005-2012 Pierre-Michel Ricordel
4 Copyright 2007-2012 Thomas Fischer
5 Copyright 2013-2020 Petr Ohlidal
6
7 For more information, see http://www.rigsofrods.org/
8
9 Rigs of Rods is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 3, as
11 published by the Free Software Foundation.
12
13 Rigs of Rods is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
20*/
21
25
26#include "RigDef_Serializer.h"
27
28#include "Actor.h"
29#include "GUIManager.h"
30#include "RigDef_File.h"
31
32#include <fstream>
33#include <OgreStringConverter.h>
34#include <iomanip>
35#include <unordered_map>
36
37using namespace RoR;
38using namespace RigDef;
39using namespace std;
40
41Serializer::Serializer(RigDef::DocumentPtr def_file):
42 m_rig_def(def_file),
43 m_node_id_width(5),
44 m_inertia_function_width(10),
45 m_bool_width(5), // strlen("false") == 5
46 m_command_key_width(2),
47 m_float_width(10)
48{}
49
50void Serializer::Serialize()
51{
52 // Write banner
53 m_stream
54 << "; ---------------------------------------------------------------------------- ;" << endl
55 << "; Project: Rigs of Rods (http://www.rigsofrods.org) ;" << endl
56 << "; File format: https://docs.rigsofrods.org/vehicle-creation/fileformat-truck ;" << endl
57 << "; ---------------------------------------------------------------------------- ;" << endl
58 << endl;
59
60 // Write name
61 m_stream << m_rig_def->name << endl << endl;
62
63 // Select source
64 Document::Module* source_module = m_rig_def->root_module.get();
65
66 // Write individual elements
67
68 // About
69 ProcessDescription(source_module);
70 ProcessAuthors(source_module);
71 ProcessFileinfo(source_module);
72 ProcessGuid(source_module);
73 WriteFlags();
74
75 // Modules (aka 'sectionconfig')
76 this->SerializeModule(m_rig_def->root_module);
77 for (auto module_itor: m_rig_def->user_modules)
78 {
79 this->SerializeModule(module_itor.second);
80 }
81
82 // Finalize
83 m_stream << "end" << endl;
84}
85
86void Serializer::SerializeModule(std::shared_ptr<RigDef::Document::Module> m)
87{
88 RigDef::Document::Module* source_module = m.get();
89
90 if (m->name != RigDef::ROOT_MODULE_NAME)
91 {
92 m_stream << "section -1 " << m->name << endl;
93 }
94
95 ProcessManagedMaterialsAndOptions(source_module);
96 ProcessGlobals(source_module);
97
98 // Structure
99 ProcessNodes(source_module);
100 ProcessBeams(source_module);
101 ProcessCameras(source_module);
102 ProcessShocks(source_module);
103 ProcessShocks2(source_module);
104 ProcessHydros(source_module);
105 ProcessCommands2(source_module);
106 ProcessSlideNodes(source_module);
107 ProcessTies(source_module);
108 ProcessRopes(source_module);
109 ProcessFixes(source_module);
110
111 // Wheels
112 ProcessMeshWheels(source_module);
113 ProcessMeshWheels2(source_module);
114 ProcessWheels(source_module);
115 ProcessWheels2(source_module);
116 ProcessFlexBodyWheels(source_module);
117
118 // Driving
119 ProcessEngine(source_module);
120 ProcessEngoption(source_module);
121 ProcessBrakes(source_module);
122 ProcessAntiLockBrakes(source_module);
123 ProcessTractionControl(source_module);
124 ProcessTorqueCurve(source_module);
125 ProcessCruiseControl(source_module);
126 ProcessSpeedLimiter(source_module);
127 ProcessAxles(source_module);
128 ProcessTransferCase(source_module);
129 ProcessInterAxles(source_module);
130
131 // Features
132 ProcessCinecam(source_module);
133 ProcessAnimators(source_module);
134 ProcessContacters(source_module);
135 ProcessTriggers(source_module);
136 ProcessLockgroups(source_module);
137 ProcessHooks(source_module);
138 ProcessRailGroups(source_module);
139 ProcessRopables(source_module);
140 ProcessParticles(source_module);
141 ProcessCollisionBoxes(source_module);
142 // TODO: detacher_group
143 ProcessFlares2(source_module);
144 ProcessMaterialFlareBindings(source_module);
145 ProcessPropsAndAnimations(source_module);
146 ProcessSubmesh(source_module);
147 ProcessSubmeshGroundmodel(source_module);
148 ProcessExhausts(source_module);
149 ProcessGuiSettings(source_module);
150 ProcessSetSkeletonSettings(source_module);
151 ProcessVideocamera(source_module);
152 ProcessExtCamera(source_module);
153 ProcessSoundsources(source_module);
154 ProcessSoundsources2(source_module);
155 ProcessCustomDashboardInputs(source_module);
156
157 // Aerial
158 ProcessWings(source_module);
159 ProcessAirbrakes(source_module);
160 ProcessTurboprops(source_module);
161 ProcessFusedrag(source_module);
162 ProcessPistonprops(source_module);
163 ProcessTurbojets(source_module);
164
165 // Marine
166 ProcessScrewprops(source_module);
167
168 if (m->name != RigDef::ROOT_MODULE_NAME)
169 {
170 m_stream << "endsection" << endl;
171 }
172}
173
174void Serializer::ProcessPistonprops(Document::Module* module)
175{
176 if (module->pistonprops.empty())
177 {
178 return;
179 }
180 m_stream << "pistonprops" << endl;
181 auto end_itor = module->pistonprops.end();
182 for (auto itor = module->pistonprops.begin(); itor != end_itor; ++itor)
183 {
184 this->ExportDocComment(module, Keyword::PISTONPROPS, std::distance(module->pistonprops.begin(), itor));
185
186 auto & def = *itor;
187
188 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
189 << ", " << setw(m_node_id_width) << def.axis_node.Str()
190 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[0].Str()
191 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[1].Str()
192 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[2].Str()
193 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[3].Str()
194 << ", " << setw(m_node_id_width) << (def.couple_node.IsValidAnyState() ? def.couple_node.Str() : "-1")
195 << ", " << setw(m_float_width) << def.turbine_power_kW
196 << ", " << setw(m_float_width) << def.pitch
197 << ", " << def.airfoil
198 << endl;
199 }
200 m_stream << endl; // Empty line
201}
202
203void Serializer::ProcessTurbojets(Document::Module* module)
204{
205 if (module->turbojets.empty())
206 {
207 return;
208 }
209 m_stream << "turbojets" << endl;
210 auto end_itor = module->turbojets.end();
211 for (auto itor = module->turbojets.begin(); itor != end_itor; ++itor)
212 {
213 this->ExportDocComment(module, Keyword::TURBOJETS, std::distance(module->turbojets.begin(), itor));
214
215 auto & def = *itor;
216
217 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.front_node.Str()
218 << ", " << setw(m_node_id_width) << def.back_node.Str()
219 << ", " << setw(m_node_id_width) << def.side_node.Str()
220 << ", " << setw(2) << def.is_reversable
221 << ", " << setw(m_float_width) << def.dry_thrust
222 << ", " << setw(m_float_width) << def.wet_thrust
223 << ", " << setw(m_float_width) << def.front_diameter
224 << ", " << setw(m_float_width) << def.back_diameter
225 << ", " << setw(m_float_width) << def.nozzle_length
226 << endl;
227 }
228 m_stream << endl; // Empty line
229}
230
231void Serializer::ProcessScrewprops(Document::Module* module)
232{
233 if (module->screwprops.empty())
234 {
235 return;
236 }
237 m_stream << "screwprops" << endl;
238 auto end_itor = module->screwprops.end();
239 for (auto itor = module->screwprops.begin(); itor != end_itor; ++itor)
240 {
241 this->ExportDocComment(module, Keyword::SCREWPROPS, std::distance(module->screwprops.begin(), itor));
242
243 auto & def = *itor;
244
245 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.prop_node.Str()
246 << ", " << setw(m_node_id_width) << def.back_node.Str()
247 << ", " << setw(m_node_id_width) << def.top_node.Str()
248 << ", " << setw(m_float_width) << def.power
249 << endl;
250 }
251 m_stream << endl; // Empty line
252}
253
254void Serializer::ProcessFusedrag(Document::Module* module)
255{
256 m_stream << "fusedrag" << endl;
257 for (RigDef::Fusedrag& def: module->fusedrag)
258 {
259 m_stream << m_dataline_indentstr
260 << setw(m_node_id_width) << def.front_node.Str() << ", "
261 << setw(m_node_id_width) << def.rear_node.Str() << ", ";
262 if (def.autocalc)
263 {
264 m_stream << "autocalc, " << setw(m_float_width) << def.area_coefficient;
265 }
266 else
267 {
268 m_stream << setw(m_float_width) << def.approximate_width;
269 }
270 m_stream << ", " << def.airfoil_name
271 << endl;
272 }
273
274 m_stream << endl; // Empty line
275}
276
277void Serializer::ProcessTurboprops(Document::Module* module)
278{
279 if (module->turboprops2.empty())
280 {
281 return;
282 }
283 m_stream << "turboprops" << endl;
284 auto end_itor = module->turboprops2.end();
285 for (auto itor = module->turboprops2.begin(); itor != end_itor; ++itor)
286 {
287 this->ExportDocComment(module, Keyword::TURBOPROPS, std::distance(module->turboprops2.begin(), itor));
288
289 RigDef::Turboprop2 & def = *itor;
290
291 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
292 << ", " << setw(m_node_id_width) << def.axis_node.Str()
293 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[0].Str()
294 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[1].Str()
295 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[2].Str()
296 << ", " << setw(m_node_id_width) << def.blade_tip_nodes[3].Str()
297 << ", " << setw(m_float_width) << def.turbine_power_kW
298 << ", " << def.airfoil
299 << endl;
300 }
301 m_stream << endl; // Empty line
302}
303
304void Serializer::ProcessAirbrakes(Document::Module* module)
305{
306 if (module->airbrakes.empty())
307 {
308 return;
309 }
310 m_stream << "airbrakes" << endl;
311 auto end_itor = module->airbrakes.end();
312 for (auto itor = module->airbrakes.begin(); itor != end_itor; ++itor)
313 {
314 this->ExportDocComment(module, Keyword::AIRBRAKES, std::distance(module->airbrakes.begin(), itor));
315
316 RigDef::Airbrake & def = *itor;
317
318 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
319 << ", " << setw(m_node_id_width) << def.x_axis_node.Str()
320 << ", " << setw(m_node_id_width) << def.y_axis_node.Str()
321 << ", " << setw(m_node_id_width) << (def.aditional_node.IsValidAnyState() ? def.aditional_node.Str() : "-1")
322 << ", " << setw(m_float_width) << def.offset.x
323 << ", " << setw(m_float_width) << def.offset.y
324 << ", " << setw(m_float_width) << def.offset.z
325 << ", " << setw(m_float_width) << def.width
326 << ", " << setw(m_float_width) << def.height
327 << ", " << setw(m_float_width) << def.max_inclination_angle
328 << ", " << setw(m_float_width) << def.texcoord_x1
329 << ", " << setw(m_float_width) << def.texcoord_y1
330 << ", " << setw(m_float_width) << def.texcoord_x2
331 << ", " << setw(m_float_width) << def.texcoord_y2
332 << ", " << setw(m_float_width) << def.lift_coefficient
333 << endl;
334 }
335 m_stream << endl; // Empty line
336}
337
338void Serializer::ProcessWings(Document::Module* module)
339{
340 if (module->wings.empty())
341 {
342 return;
343 }
344 m_stream << "wings" << endl;
345 auto end_itor = module->wings.end();
346 for (auto itor = module->wings.begin(); itor != end_itor; ++itor)
347 {
348 this->ExportDocComment(module, Keyword::WINGS, std::distance(module->wings.begin(), itor));
349
350 RigDef::Wing & def = *itor;
351
352 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.nodes[0].Str()
353 << ", " << setw(m_node_id_width) << def.nodes[1].Str()
354 << ", " << setw(m_node_id_width) << def.nodes[2].Str()
355 << ", " << setw(m_node_id_width) << def.nodes[3].Str()
356 << ", " << setw(m_node_id_width) << def.nodes[4].Str()
357 << ", " << setw(m_node_id_width) << def.nodes[5].Str()
358 << ", " << setw(m_node_id_width) << def.nodes[6].Str()
359 << ", " << setw(m_node_id_width) << def.nodes[7].Str()
360 << ", " << setw(m_float_width) << def.tex_coords[0]
361 << ", " << setw(m_float_width) << def.tex_coords[1]
362 << ", " << setw(m_float_width) << def.tex_coords[2]
363 << ", " << setw(m_float_width) << def.tex_coords[3]
364 << ", " << setw(m_float_width) << def.tex_coords[4]
365 << ", " << setw(m_float_width) << def.tex_coords[5]
366 << ", " << setw(m_float_width) << def.tex_coords[6]
367 << ", " << setw(m_float_width) << def.tex_coords[7]
368 << ", " << (char)def.control_surface
369 << ", " << setw(m_float_width) << def.chord_point
370 << ", " << setw(m_float_width) << def.min_deflection
371 << ", " << setw(m_float_width) << def.max_deflection
372 << ", " << def.airfoil
373 << ", " << def.efficacy_coef
374 << endl;
375 }
376 m_stream << endl; // Empty line
377}
378
379void Serializer::ProcessSoundsources(Document::Module* module)
380{
381 if (module->soundsources.empty())
382 {
383 return;
384 }
385 m_stream << "soundsources" << endl;
386 auto end_itor = module->soundsources.end();
387 for (auto itor = module->soundsources.begin(); itor != end_itor; ++itor)
388 {
389 this->ExportDocComment(module, Keyword::SOUNDSOURCES, std::distance(module->soundsources.begin(), itor));
390
391 RigDef::SoundSource & def = *itor;
392
393 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.node.Str() << ", " << def.sound_script_name
394 << endl;
395 }
396 m_stream << endl; // Empty line
397}
398
399void Serializer::ProcessSoundsources2(Document::Module* module)
400{
401 if (module->soundsources2.empty())
402 {
403 return;
404 }
405 m_stream << "soundsources2" << endl;
406 auto end_itor = module->soundsources2.end();
407 for (auto itor = module->soundsources2.begin(); itor != end_itor; ++itor)
408 {
409 this->ExportDocComment(module, Keyword::SOUNDSOURCES2, std::distance(module->soundsources2.begin(), itor));
410
411 RigDef::SoundSource2 & def = *itor;
412
413 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.node.Str()
414 << ", " << setw(2) << def.mode
415 << ", " << def.sound_script_name
416 << endl;
417 }
418 m_stream << endl; // Empty line
419}
420
421void Serializer::ProcessCustomDashboardInputs(Document::Module* module)
422{
423 if (module->customdashboardinputs.empty())
424 {
425 return;
426 }
427
428 m_stream << "customdashboardinputs" << endl;
429 auto end_itor = module->customdashboardinputs.end();
430 for (auto itor = module->customdashboardinputs.begin(); itor != end_itor; ++itor)
431 {
432 this->ExportDocComment(module, Keyword::CUSTOMDASHBOARDINPUTS, std::distance(module->customdashboardinputs.begin(), itor));
433
434 CustomDashboardInput& dash_val = *itor;
435
436 m_stream << dash_val.name << " ";
437 switch (dash_val.data_type)
438 {
439 case DC_BOOL:
440 m_stream << "bool";
441 break;
442 case DC_FLOAT:
443 m_stream << "float";
444 break;
445 case DC_INT:
446 m_stream << "int";
447 break;
448 case DC_CHAR:
449 m_stream << "string";
450 break;
451 }
452
453 m_stream << endl;
454 }
455 m_stream << endl; // Empty line
456}
457
458void Serializer::ProcessExtCamera(Document::Module* module)
459{
460 if (module->extcamera.size() == 0)
461 {
462 return;
463 }
464 RigDef::ExtCamera* def = &module->extcamera[0];
465 m_stream << "extcamera ";
466
467 switch (def->mode)
468 {
469 case ExtCameraMode::NODE:
470 m_stream << "node " << def->node.Str();
471 break;
472 case ExtCameraMode::CINECAM:
473 m_stream << "cinecam";
474 break;
475 case ExtCameraMode::CLASSIC:
476 default:
477 m_stream << "classic";
478 break;
479 }
480 m_stream << "\n\n";
481}
482
483void Serializer::ProcessVideocamera(Document::Module* module)
484{
485 if (module->videocameras.empty())
486 {
487 return;
488 }
489 m_stream << "videocamera" << endl;
490 auto end_itor = module->videocameras.end();
491 for (auto itor = module->videocameras.begin(); itor != end_itor; ++itor)
492 {
493 this->ExportDocComment(module, Keyword::VIDEOCAMERA, std::distance(module->videocameras.begin(), itor));
494
495 RigDef::VideoCamera & def = *itor;
496
497 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
498 << ", " << setw(m_node_id_width) << def.left_node.Str()
499 << ", " << setw(m_node_id_width) << def.bottom_node.Str()
500 << ", " << setw(m_node_id_width) << (def.alt_reference_node.IsValidAnyState() ? def.alt_reference_node.Str() : "-1")
501 << ", " << setw(m_node_id_width) << (def.alt_orientation_node.IsValidAnyState() ? def.alt_orientation_node.Str() : "-1")
502 << ", " << setw(m_float_width) << def.offset.x
503 << ", " << setw(m_float_width) << def.offset.y
504 << ", " << setw(m_float_width) << def.offset.z
505 << ", " << setw(m_float_width) << def.rotation.x
506 << ", " << setw(m_float_width) << def.rotation.y
507 << ", " << setw(m_float_width) << def.rotation.z
508 << ", " << setw(m_float_width) << def.field_of_view
509 << ", " << setw(4) << def.texture_width
510 << ", " << setw(4) << def.texture_height
511 << ", " << setw(m_float_width) << def.min_clip_distance
512 << ", " << setw(m_float_width) << def.max_clip_distance
513 << ", " << setw(3) << def.camera_role
514 << ", " << setw(3) << def.camera_mode
515 << ", " << def.material_name;
516 if (!def.camera_name.empty())
517 {
518 m_stream << ", " << def.camera_name;
519 }
520
521 m_stream << endl;
522 }
523 m_stream << endl; // Empty line
524}
525
526void Serializer::ProcessSetSkeletonSettings(Document::Module* module)
527{
528 if (module->set_skeleton_settings.empty())
529 {
530 return;
531 }
532
533 RigDef::SkeletonSettings& def = module->set_skeleton_settings[module->set_skeleton_settings.size() - 1];
534 m_stream << "set_skeleton_settings " << def.visibility_range_meters << ", " << def.beam_thickness_meters << "\n\n";
535}
536
537void Serializer::ProcessGuiSettings(Document::Module* module)
538{
539 if (module->guisettings.empty())
540 {
541 return;
542 }
543 m_stream << "guisettings" << endl;
544 for (GuiSettings& gs: module->guisettings)
545 {
546 m_stream << m_dataline_indentstr << gs.key << " " << gs.value
547 << endl;
548 }
549 m_stream << endl; // Empty line
550}
551
552void Serializer::ProcessExhausts(Document::Module* module)
553{
554 if (module->exhausts.empty())
555 {
556 return;
557 }
558 m_stream << "exhausts" << endl;
559 auto end_itor = module->exhausts.end();
560 for (auto itor = module->exhausts.begin(); itor != end_itor; ++itor)
561 {
562 this->ExportDocComment(module, Keyword::EXHAUSTS, std::distance(module->exhausts.begin(), itor));
563
564 RigDef::Exhaust & def = *itor;
565
566 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
567 << ", " << setw(m_node_id_width) << def.direction_node.Str()
568 << ", " << def.particle_name
569 << endl;
570 }
571 m_stream << endl; // Empty line
572}
573
574void Serializer::ProcessSubmeshGroundmodel(Document::Module* module)
575{
576 if (module->submesh_groundmodel.empty())
577 {
578 return;
579 }
580
581 m_stream << "submesh_groundmodel " << module->submesh_groundmodel.back() << endl << endl; // Empty line
582}
583
584void Serializer::ProcessSubmesh(Document::Module* module)
585{
586 for (RigDef::Submesh & def: module->submeshes)
587 {
588 m_stream << "submesh" << endl;
589
590 if (def.texcoords.size() > 0)
591 {
592 m_stream << "texcoords" << endl;
593 auto texcoord_end = def.texcoords.end();
594 for (auto texcoord_itor = def.texcoords.begin(); texcoord_itor != texcoord_end; ++texcoord_itor)
595 {
596 m_stream << m_dataline_indentstr << setw(m_node_id_width) << texcoord_itor->node.Str() << ", " << texcoord_itor->u << ", " << texcoord_itor->v << endl;
597 }
598 }
599 if (def.cab_triangles.size() > 0)
600 {
601 m_stream << "cab" << endl;
602 auto cab_end = def.cab_triangles.end();
603 for (auto cab_itor = def.cab_triangles.begin(); cab_itor != cab_end; ++cab_itor)
604 {
605 m_stream << m_dataline_indentstr << setw(m_node_id_width) << cab_itor->nodes[0].Str()
606 << ", " << setw(m_node_id_width) << cab_itor->nodes[1].Str()
607 << ", " << setw(m_node_id_width) << cab_itor->nodes[2].Str()
608 << ", n";
609
610 // Options
611 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_c_CONTACT )) m_stream << (char)CabOption::c_CONTACT;
612 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_b_BUOYANT )) m_stream << (char)CabOption::b_BUOYANT;
613 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_p_10xTOUGHER )) m_stream << (char)CabOption::p_10xTOUGHER;
614 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_u_INVULNERABLE )) m_stream << (char)CabOption::u_INVULNERABLE;
615 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_s_BUOYANT_NO_DRAG )) m_stream << (char)CabOption::s_BUOYANT_NO_DRAG;
616 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_r_BUOYANT_ONLY_DRAG )) m_stream << (char)CabOption::r_BUOYANT_ONLY_DRAG;
617 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_D_CONTACT_BUOYANT )) m_stream << (char)CabOption::D_CONTACT_BUOYANT;
618 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_F_10xTOUGHER_BUOYANT )) m_stream << (char)CabOption::F_10xTOUGHER_BUOYANT;
619 if (BITMASK_IS_1(cab_itor->options, Cab::OPTION_S_INVULNERABLE_BUOYANT)) m_stream << (char)CabOption::S_INVULNERABLE_BUOYANT;
620 m_stream << endl;
621 }
622 }
623 if (def.backmesh)
624 {
625 m_stream << "backmesh" << endl;
626 }
627 m_stream << endl; // Empty line
628 }
629}
630
631inline void PropAnimFlag(std::stringstream& out, int flags, bool& join, unsigned int mask, const char* name, char joiner = '|')
632{
633 if (flags & mask)
634 {
635 if (join)
636 {
637 out << joiner;
638 }
639 out << name;
640 join = true;
641 }
642}
643
644void Serializer::ProcessDirectiveAddAnimation(RigDef::Animation & anim)
645{
646 m_stream << "\tadd_animation "
647 << setw(m_float_width) << anim.ratio << ", "
648 << setw(m_float_width) << anim.lower_limit << ", "
649 << setw(m_float_width) << anim.upper_limit << ", "
650 << "source: ";
651
652 // Source flags
653 bool join = false;
654 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_AIRSPEED , "airspeed");
655 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_VERTICAL_VELOCITY, "vvi");
656 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ALTIMETER_100K , "altimeter100k");
657 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ALTIMETER_10K , "altimeter10k");
658 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ALTIMETER_1K , "altimeter1k");
659 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ANGLE_OF_ATTACK , "aoa");
660 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_FLAP , "flap");
661 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_AIR_BRAKE , "airbrake");
662 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ROLL , "roll");
663 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_PITCH , "pitch");
664 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_BRAKES , "brakes");
665 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ACCEL , "accel");
666 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_CLUTCH , "clutch");
667 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_SPEEDO , "speedo");
668 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_TACHO , "tacho");
669 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_TURBO , "turbo");
670 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_PARKING , "parking");
671 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_SHIFT_LEFT_RIGHT , "shifterman1");
672 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_SHIFT_BACK_FORTH , "shifterman2");
673 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_SEQUENTIAL_SHIFT , "sequential");
674 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_SHIFTERLIN , "shifterlin");
675 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_TORQUE , "torque");
676 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_HEADING , "heading");
677 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_DIFFLOCK , "difflock");
678 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_BOAT_RUDDER , "rudderboat");
679 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_BOAT_THROTTLE , "throttleboat");
680 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_STEERING_WHEEL , "steeringwheel");
681 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_AILERON , "aileron");
682 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_ELEVATOR , "elevator");
683 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_AIR_RUDDER , "rudderair");
684 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_PERMANENT , "permanent");
685 PropAnimFlag(m_stream, anim.source, join, Animation::SOURCE_EVENT , "event");
686
687 m_stream << ", mode: ";
688 join = false;
689 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_ROTATION_X , "x-rotation");
690 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_ROTATION_Y , "y-rotation");
691 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_ROTATION_Z , "z-rotation");
692 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_OFFSET_X , "x-offset");
693 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_OFFSET_Y , "y-offset");
694 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_OFFSET_Z , "z-offset");
695
696 // Solo flags
697 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_AUTO_ANIMATE, " autoanimate", ',');
698 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_NO_FLIP , " noflip" , ',');
699 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_BOUNCE , " bounce" , ',');
700 PropAnimFlag(m_stream, anim.mode, join, Animation::MODE_EVENT_LOCK , " eventlock" , ',');
701
702 if (BITMASK_IS_1(anim.source, RigDef::Animation::SOURCE_EVENT))
703 {
704 m_stream << ", event: " << anim.event_name;
705 }
706 m_stream << endl;
707}
708
709void Serializer::ProcessFlexbodies(Document::Module* module)
710{
711 if (module->flexbodies.empty())
712 {
713 return;
714 }
715 m_stream << "flexbodies" << endl;
716 auto end_itor = module->flexbodies.end();
717 for (auto itor = module->flexbodies.begin(); itor != end_itor; ++itor)
718 {
719 this->ExportDocComment(module, Keyword::FLEXBODIES, std::distance(module->flexbodies.begin(), itor));
720
721 RigDef::Flexbody* def = &*itor;
722
723 // Prop-like line
724 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def->reference_node.Str()
725 << ", " << setw(m_node_id_width) << def->x_axis_node.Str()
726 << ", " << setw(m_node_id_width) << def->y_axis_node.Str()
727 << ", " << setw(m_float_width) << def->offset.x
728 << ", " << setw(m_float_width) << def->offset.y
729 << ", " << setw(m_float_width) << def->offset.z
730 << ", " << setw(m_float_width) << def->rotation.x
731 << ", " << setw(m_float_width) << def->rotation.y
732 << ", " << setw(m_float_width) << def->rotation.z
733 << ", " << def->mesh_name
734 << endl;
735
736 // Forset line
737 m_stream << m_dataline_indentstr << "forset ";
738 auto forset_end = def->node_list.end();
739 auto forset_itor = def->node_list.begin();
740 bool first = true;
741 for (; forset_itor != forset_end; ++forset_itor)
742 {
743 if (!first)
744 {
745 m_stream << ", ";
746 }
747 m_stream << forset_itor->Str();
748 first = false;
749 }
750 m_stream
751 << endl;
752
753 // Animations
754 auto anim_end = def->animations.end();
755 for (auto anim_itor = def->animations.begin(); anim_itor != anim_end; ++anim_itor)
756 {
757 ProcessDirectiveAddAnimation(*anim_itor);
758 }
759 }
760 m_stream << endl; // Empty line
761}
762
763void Serializer::ProcessPropsAndAnimations(Document::Module* module)
764{
765 if (module->props.empty())
766 {
767 return;
768 }
769 m_stream << "props" << endl;
770 auto end_itor = module->props.end();
771 for (auto itor = module->props.begin(); itor != end_itor; ++itor)
772 {
773 this->ExportDocComment(module, Keyword::PROPS, std::distance(module->props.begin(), itor));
774
775 RigDef::Prop & def = *itor;
776
777 m_stream << "\t" << setw(m_node_id_width) << def.reference_node.Str()
778 << ", " << setw(m_node_id_width) << def.x_axis_node.Str()
779 << ", " << setw(m_node_id_width) << def.y_axis_node.Str()
780 << ", " << setw(m_float_width) << def.offset.x
781 << ", " << setw(m_float_width) << def.offset.y
782 << ", " << setw(m_float_width) << def.offset.z
783 << ", " << setw(m_float_width) << def.rotation.x
784 << ", " << setw(m_float_width) << def.rotation.y
785 << ", " << setw(m_float_width) << def.rotation.z
786 << ", " << def.mesh_name;
787
788 // Special props
789 if (def.special == SpecialProp::BEACON)
790 {
791 m_stream
792 << ", " << def.special_prop_beacon.flare_material_name
793 << ", " << def.special_prop_beacon.color.r
794 << ", " << def.special_prop_beacon.color.g
795 << ", " << def.special_prop_beacon.color.b;
796 }
797 else if (def.special == SpecialProp::DASHBOARD_LEFT || def.special == SpecialProp::DASHBOARD_RIGHT)
798 {
799 m_stream << ", " << def.special_prop_dashboard.mesh_name; // The steering wheel mesh
800 if (def.special_prop_dashboard._offset_is_set)
801 {
802 m_stream
803 << ", " << def.special_prop_dashboard.offset.x
804 << ", " << def.special_prop_dashboard.offset.y
805 << ", " << def.special_prop_dashboard.offset.z
806 << ", " << def.special_prop_dashboard.rotation_angle;
807 }
808 }
809
810 m_stream << endl;
811
812 // Animations
813 auto anim_end = def.animations.end();
814 for (auto anim_itor = def.animations.begin(); anim_itor != anim_end; ++anim_itor)
815 {
816 ProcessDirectiveAddAnimation(*anim_itor);
817 }
818 }
819 m_stream << endl; // Empty line
820}
821
822void Serializer::ProcessMaterialFlareBindings(Document::Module* module)
823{
824 if (module->materialflarebindings.empty())
825 {
826 return;
827 }
828 m_stream << "materialflarebindings" << endl;
829 auto end_itor = module->materialflarebindings.end();
830 for (auto itor = module->materialflarebindings.begin(); itor != end_itor; ++itor)
831 {
832 RigDef::MaterialFlareBinding & def = *itor;
833 m_stream << m_dataline_indentstr << def.flare_number << ", " << def.material_name
834 << endl;
835 }
836 m_stream << endl; // Empty line
837}
838
839void Serializer::ProcessFlares2(Document::Module* module)
840{
841 if (module->flares2.empty())
842 {
843 return;
844 }
845 m_stream << "flares2" << endl;
846 auto end_itor = module->flares2.end();
847 for (auto itor = module->flares2.begin(); itor != end_itor; ++itor)
848 {
849 this->ExportDocComment(module, Keyword::FLARES2, std::distance(module->flares2.begin(), itor));
850
851 RigDef::Flare2 & def = *itor;
852
853 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.reference_node.Str()
854 << ", " << setw(m_node_id_width) << def.node_axis_x.Str()
855 << ", " << setw(m_node_id_width) << def.node_axis_y.Str()
856 << ", " << setw(m_float_width) << def.offset.x
857 << ", " << setw(m_float_width) << def.offset.y
858 << ", " << setw(m_float_width) << def.offset.z
859 << ", " << (char)def.type
860 << ", " << setw(2) << def.control_number
861 << ", " << setw(4) << def.blink_delay_milis
862 << ", " << setw(m_float_width) << def.size
863 << ", " << def.material_name
864 << endl;
865 }
866 m_stream << endl; // Empty line
867}
868
869void Serializer::ProcessManagedMaterialsAndOptions(Document::Module* module)
870{
871 if (module->managedmaterials.empty())
872 {
873 return;
874 }
875
876 // Calc column widths
877 size_t name_w = 0, type_w = 0, tex1_w = 0, tex2_w = 1, tex3_w = 1; // Handle space for '-' empty tex marker
878 for (ManagedMaterial& mm: module->managedmaterials)
879 {
880 name_w = std::max(name_w, mm.name.length());
881 type_w = std::max(type_w, strlen(RigDef::ManagedMaterial::TypeToStr(mm.type)));
882 tex1_w = std::max(tex1_w, mm.diffuse_map.size());
883 tex2_w = std::max(tex2_w, mm.damaged_diffuse_map.length());
884 tex3_w = std::max(tex3_w, mm.specular_map.length());
885 }
886
887 m_stream << "managedmaterials" << std::left << endl; // Set left alignment. WARNING - PERSISTENT!
888 bool first = true;
889 ManagedMaterialsOptions mm_options;
890 for (ManagedMaterial& def: module->managedmaterials)
891 {
892 if (first || (mm_options.double_sided != def.options.double_sided))
893 {
894 mm_options.double_sided = def.options.double_sided;
895 m_stream << "set_managedmaterials_options " << (int) mm_options.double_sided
896 << endl;
897 }
898
899 m_stream << m_dataline_indentstr
900 << setw(name_w) << def.name << " "
901 << setw(type_w) << RigDef::ManagedMaterial::TypeToStr(def.type) << " "
902 << setw(tex1_w) << def.diffuse_map << " ";
903
904 // Damage diffuse map - empty column if not applicable
905 if (def.type == ManagedMaterialType::FLEXMESH_STANDARD || def.type == ManagedMaterialType::FLEXMESH_TRANSPARENT)
906 {
907 m_stream << setw(tex2_w) << (def.damaged_diffuse_map.empty() ? "-" : def.damaged_diffuse_map) << " ";
908 }
909 else
910 {
911 m_stream << setw(tex2_w) << "" << " ";
912 }
913
914 m_stream << setw(tex3_w) << (def.specular_map.empty() ? "-" : def.specular_map);
915
916 first = false;
917 m_stream
918 << endl;
919 }
920 m_stream << std::right; // Reset to default alignment
921 m_stream << endl; // Empty line
922}
923
924void Serializer::ProcessCollisionBoxes(Document::Module* module)
925{
926 if (module->collisionboxes.empty())
927 {
928 return;
929 }
930 m_stream << "collisionboxes" << endl;
931 auto end_itor = module->collisionboxes.end();
932 for (auto itor = module->collisionboxes.begin(); itor != end_itor; ++itor)
933 {
934 this->ExportDocComment(module, Keyword::COLLISIONBOXES, std::distance(module->collisionboxes.begin(), itor));
935
936 RigDef::CollisionBox & def = *itor;
937
938 auto nodes_end = def.nodes.end();
939 auto node_itor = def.nodes.begin();
940 m_stream << node_itor->Str();
941 ++node_itor;
942 for (; node_itor != nodes_end; ++node_itor)
943 {
944 m_stream << ", " << node_itor->Str();
945 }
946
947 m_stream << endl;
948 }
949 m_stream << endl; // Empty line
950}
951
952void Serializer::ProcessAxles(Document::Module* module)
953{
954 if (module->axles.empty())
955 {
956 return;
957 }
958 m_stream << "axles" << endl;
959 auto end_itor = module->axles.end();
960 for (auto itor = module->axles.begin(); itor != end_itor; ++itor)
961 {
962 this->ExportDocComment(module, Keyword::AXLES, std::distance(module->axles.begin(), itor));
963
964 RigDef::Axle & def = *itor;
965
966 m_stream << m_dataline_indentstr
967 << "w1(" << def.wheels[0][0].Str() << " " << def.wheels[0][1].Str() << "), "
968 << "w2(" << def.wheels[1][0].Str() << " " << def.wheels[1][1].Str() << ")";
969 if (! def.options.empty())
970 {
971 m_stream << ", d(";
972 auto end = def.options.end();
973 for (auto itor = def.options.begin(); itor != end; ++itor)
974 {
975 m_stream << (char)*itor;
976 }
977 m_stream << ")";
978 }
979 m_stream << endl;
980 }
981 m_stream << endl; // Empty line
982}
983
984void Serializer::ProcessInterAxles(Document::Module* module)
985{
986 if (module->interaxles.empty())
987 {
988 return;
989 }
990 m_stream << "interaxles" << endl;
991 auto end_itor = module->interaxles.end();
992 for (auto itor = module->interaxles.begin(); itor != end_itor; ++itor)
993 {
994 this->ExportDocComment(module, Keyword::INTERAXLES, std::distance(module->interaxles.begin(), itor));
995
996 RigDef::InterAxle & def = *itor;
997
998 m_stream << m_dataline_indentstr
999 << def.a1 << ", "
1000 << def.a2;
1001 if (! def.options.empty())
1002 {
1003 m_stream << ", d(";
1004 auto end = def.options.end();
1005 for (auto itor = def.options.begin(); itor != end; ++itor)
1006 {
1007 m_stream << (char)*itor;
1008 }
1009 m_stream << ")";
1010 }
1011 m_stream << endl;
1012 }
1013 m_stream << endl; // Empty line
1014}
1015
1016void Serializer::ProcessTransferCase(Document::Module* module)
1017{
1018 if (module->transfercase.size() == 0)
1019 {
1020 return;
1021 }
1022 TransferCase& def = module->transfercase[module->transfercase.size() - 1];
1023
1024 m_stream << "transfercase\t"
1025 << def.a1 << ", "
1026 << def.a2 << ", "
1027 << def.has_2wd << ", "
1028 << def.has_2wd_lo;
1029 for (float gear_ratio : def.gear_ratios)
1030 {
1031 m_stream << ", " << gear_ratio;
1032 }
1033 m_stream << endl << endl;
1034}
1035
1036void Serializer::ProcessCruiseControl(Document::Module* module)
1037{
1038 if (module->cruisecontrol.size() == 0)
1039 {
1040 return;
1041 }
1042
1043 RigDef::CruiseControl& cruisecontrol = module->cruisecontrol[module->cruisecontrol.size() - 1];
1044
1045 m_stream << "cruisecontrol "
1046 << cruisecontrol.min_speed << ", "
1047 << (int) cruisecontrol.autobrake
1048 << endl << endl;
1049
1050}
1051
1052void Serializer::ProcessSpeedLimiter(Document::Module* module)
1053{
1054 if (module->speedlimiter.size() == 0)
1055 {
1056 return;
1057 }
1058 m_stream << "speedlimiter "
1059 << module->speedlimiter[module->speedlimiter.size() - 1].max_speed
1060 << endl << endl;
1061}
1062
1063void Serializer::ProcessTorqueCurve(Document::Module* module)
1064{
1065 if (module->torquecurve.size() == 0)
1066 {
1067 return;
1068 }
1069 m_stream << "torquecurve" << endl;
1070 if (module->torquecurve[0].predefined_func_name.empty())
1071 {
1072 auto itor_end = module->torquecurve[0].samples.end();
1073 auto itor = module->torquecurve[0].samples.begin();
1074 for (; itor != itor_end; ++itor)
1075 {
1076 m_stream << m_dataline_indentstr << itor->power << ", " << itor->torque_percent;
1077 }
1078 }
1079 else
1080 {
1081 m_stream << m_dataline_indentstr << module->torquecurve[0].predefined_func_name;
1082 }
1083 m_stream << endl; // Empty line
1084}
1085
1086void Serializer::ProcessParticles(Document::Module* module)
1087{
1088 if (module->particles.empty())
1089 {
1090 return;
1091 }
1092 m_stream << "particles" << endl;
1093 auto end_itor = module->particles.end();
1094 for (auto itor = module->particles.begin(); itor != end_itor; ++itor)
1095 {
1096 this->ExportDocComment(module, Keyword::PARTICLES, std::distance(module->particles.begin(), itor));
1097
1098 RigDef::Particle & def = *itor;
1099
1100 m_stream << m_dataline_indentstr
1101 << setw(m_node_id_width) << def.emitter_node.Str() << ", "
1102 << setw(m_node_id_width) << def.reference_node.Str() << ", "
1103 << def.particle_system_name;
1104 m_stream << endl;
1105 }
1106 m_stream << endl; // Empty line
1107}
1108
1109void Serializer::ProcessRopables(Document::Module* module)
1110{
1111 if (module->ropables.empty())
1112 {
1113 return;
1114 }
1115 m_stream << "ropables" << endl;
1116 auto end_itor = module->ropables.end();
1117 for (auto itor = module->ropables.begin(); itor != end_itor; ++itor)
1118 {
1119 this->ExportDocComment(module, Keyword::ROPABLES, std::distance(module->ropables.begin(), itor));
1120
1121 RigDef::Ropable & def = *itor;
1122
1123 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.node.Str()
1124 << ", " << def.group
1125 << ", " << (int) def.has_multilock;
1126 m_stream << endl;
1127 }
1128 m_stream << endl; // Empty line
1129}
1130
1131void Serializer::ProcessTies(Document::Module* module)
1132{
1133 if (module->ties.empty())
1134 {
1135 return;
1136 }
1137 m_stream << "ties" << endl;
1138 auto end_itor = module->ties.end();
1139 for (auto itor = module->ties.begin(); itor != end_itor; ++itor)
1140 {
1141 this->ExportDocComment(module, Keyword::TIES, std::distance(module->ties.begin(), itor));
1142
1143 RigDef::Tie & def = *itor;
1144
1145 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.root_node.Str()
1146 << ", " << setw(m_float_width) << def.max_reach_length
1147 << ", " << setw(m_float_width) << def.auto_shorten_rate
1148 << ", " << setw(m_float_width) << def.min_length
1149 << ", " << setw(m_float_width) << def.max_length
1150 << ", " << (BITMASK_IS_1(def.options, Tie::OPTION_i_INVISIBLE) ? "i" : "n")
1151 << ", " << (BITMASK_IS_1(def.options, Tie::OPTION_s_DISABLE_SELF_LOCK) ? "s" : "")
1152 << ", " << setw(m_float_width) << def.max_stress
1153 << ", " << def.group;
1154 m_stream << endl;
1155 }
1156 m_stream << endl; // Empty line
1157}
1158
1159void Serializer::ProcessFixes(Document::Module* module)
1160{
1161 if (module->fixes.empty())
1162 {
1163 return;
1164 }
1165 m_stream << "fixes" << endl;
1166 auto end_itor = module->fixes.end();
1167 for (auto itor = module->fixes.begin(); itor != end_itor; ++itor)
1168 {
1169 m_stream << m_dataline_indentstr << setw(m_node_id_width) << itor->Str();
1170 }
1171 m_stream << endl; // Empty line
1172}
1173
1174void Serializer::ProcessRopes(Document::Module* module)
1175{
1176 if (module->ropes.empty())
1177 {
1178 return;
1179 }
1180 m_stream << "ropes" << endl;
1181 auto end_itor = module->ropes.end();
1182 bool first = true;
1183 BeamDefaults* beam_defaults = nullptr;
1184 for (auto itor = module->ropes.begin(); itor != end_itor; ++itor)
1185 {
1186 this->ExportDocComment(module, Keyword::ROPES, std::distance(module->ropes.begin(), itor));
1187
1188 RigDef::Rope & def = *itor;
1189
1190 if (first || (def.beam_defaults.get() != beam_defaults))
1191 {
1192 ProcessBeamDefaults(def.beam_defaults.get());
1193 }
1194
1195 m_stream << m_dataline_indentstr
1196 << setw(m_node_id_width) << def.root_node.Str() << ", "
1197 << setw(m_node_id_width) << def.end_node.Str();
1198 if (def.invisible)
1199 {
1200 m_stream << ", i";
1201 }
1202 first = false;
1203 m_stream << endl;
1204 }
1205 m_stream << endl; // Empty line
1206}
1207
1208void Serializer::ProcessRailGroups(Document::Module* module)
1209{
1210 if (module->railgroups.empty())
1211 {
1212 return;
1213 }
1214 m_stream << "railgroups" << endl << endl;
1215 auto end_itor = module->railgroups.end();
1216 for (auto itor = module->railgroups.begin(); itor != end_itor; ++itor)
1217 {
1218 this->ExportDocComment(module, Keyword::RAILGROUPS, std::distance(module->railgroups.begin(), itor));
1219
1220 RigDef::RailGroup & def = *itor;
1221
1222 m_stream << m_dataline_indentstr << def.id;
1223 auto node_end = def.node_list.end();
1224 for (auto node_itor = def.node_list.begin(); node_itor != node_end; ++node_itor)
1225 {
1226 m_stream << ", " << node_itor->start.Str();
1227 if (node_itor->IsRange())
1228 {
1229 m_stream << " - " << node_itor->end.Str();
1230 }
1231 }
1232 m_stream << endl;
1233 }
1234 m_stream << endl; // Empty line
1235}
1236
1237void Serializer::ProcessSlideNodes(Document::Module* module)
1238{
1239 if (module->slidenodes.empty())
1240 {
1241 return;
1242 }
1243 m_stream << "slidenodes" << endl << endl;
1244 auto end_itor = module->slidenodes.end();
1245 for (auto itor = module->slidenodes.begin(); itor != end_itor; ++itor)
1246 {
1247 this->ExportDocComment(module, Keyword::SLIDENODES, std::distance(module->slidenodes.begin(), itor));
1248
1249 RigDef::SlideNode & def = *itor;
1250
1251 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.slide_node.Str();
1252
1253 // Define rail - either list of nodes, or raigroup ID
1254 if (!def.rail_node_ranges.empty())
1255 {
1256 auto end = def.rail_node_ranges.end();
1257 auto itor = def.rail_node_ranges.begin();
1258 for (; itor != end; ++itor)
1259 {
1260 m_stream << ", " << itor->start.Str();
1261 if (itor->IsRange())
1262 {
1263 m_stream << " - " << itor->end.Str();
1264 }
1265 }
1266 }
1267 else
1268 {
1269 m_stream << ", g" << def.railgroup_id;
1270 }
1271
1272 // Optional args
1273 if (def._spring_rate_set) { m_stream << ", s" << def.spring_rate; }
1274 if (def._break_force_set) { m_stream << ", b" << def.break_force; }
1275 if (def._tolerance_set) { m_stream << ", t" << def.tolerance; }
1276 if (def._attachment_rate_set) { m_stream << ", r" << def.attachment_rate; }
1277 if (def._max_attach_dist_set) { m_stream << ", d" << def.max_attach_dist; }
1278
1279 // Constraint flags (cX)
1280 if (BITMASK_IS_1(def.constraint_flags, SlideNode::CONSTRAINT_ATTACH_ALL )) { m_stream << ", ca"; }
1281 else if (BITMASK_IS_1(def.constraint_flags, SlideNode::CONSTRAINT_ATTACH_FOREIGN)) { m_stream << ", cf"; }
1282 else if (BITMASK_IS_1(def.constraint_flags, SlideNode::CONSTRAINT_ATTACH_SELF )) { m_stream << ", cs"; }
1283 else if (BITMASK_IS_1(def.constraint_flags, SlideNode::CONSTRAINT_ATTACH_NONE )) { m_stream << ", cn"; }
1284
1285 m_stream << endl;
1286 }
1287 m_stream << endl; // Empty line
1288}
1289
1290void Serializer::ProcessHooks(Document::Module* module)
1291{
1292 if (module->hooks.empty())
1293 {
1294 return;
1295 }
1296 m_stream << "hooks" << endl << endl;
1297 auto end_itor = module->hooks.end();
1298 for (auto itor = module->hooks.begin(); itor != end_itor; ++itor)
1299 {
1300 this->ExportDocComment(module, Keyword::HOOKS, std::distance(module->hooks.begin(), itor));
1301
1302 RigDef::Hook & def = *itor;
1303
1304 m_stream << m_dataline_indentstr << setw(m_node_id_width) << def.node.Str();
1305
1306 // Boolean options
1307 if (def.flag_auto_lock) { m_stream << ", auto-lock"; }
1308 if (def.flag_no_disable) { m_stream << ", nodisable"; }
1309 if (def.flag_no_rope) { m_stream << ", norope"; }
1310 if (def.flag_self_lock) { m_stream << ", self-lock"; }
1311 if (def.flag_visible) { m_stream << ", visible"; }
1312
1313 // Key-value options
1314 m_stream
1315 << ", hookrange: " << setw(m_float_width) << def.option_hook_range
1316 << ", speedcoef: " << setw(m_float_width) << def.option_speed_coef
1317 << ", maxforce: " << setw(m_float_width) << def.option_max_force
1318 << ", hookgroup: " << setw(4) << def.option_hookgroup
1319 << ", lockgroup: " << setw(4) << def.option_lockgroup
1320 << ", timer: " << setw(m_float_width) << def.option_timer
1321 << ", shortlimit: " << setw(m_float_width) << def.option_min_range_meters;
1322
1323 m_stream << endl;
1324 }
1325 m_stream << endl; // Empty line
1326}
1327
1328void Serializer::ProcessLockgroups(Document::Module* module)
1329{
1330 if (module->lockgroups.empty())
1331 {
1332 return;
1333 }
1334 m_stream << "lockgroups" << endl << endl;
1335 auto end_itor = module->lockgroups.end();
1336 for (auto itor = module->lockgroups.begin(); itor != end_itor; ++itor)
1337 {
1338 this->ExportDocComment(module, Keyword::LOCKGROUPS, std::distance(module->lockgroups.begin(), itor));
1339
1340 RigDef::Lockgroup & def = *itor;
1341
1342 m_stream << m_dataline_indentstr << def.number;
1343 auto nodes_end = def.nodes.end();
1344 for (auto nodes_itor = def.nodes.begin(); nodes_itor != nodes_end; ++nodes_itor)
1345 {
1346 m_stream << ", " << nodes_itor->Str();
1347 }
1348 m_stream << endl;
1349 }
1350 m_stream << endl; // Empty line
1351}
1352
1353void Serializer::ProcessTriggers(Document::Module* module)
1354{
1355 if (module->triggers.empty())
1356 {
1357 return;
1358 }
1359 m_stream << "animators" << endl << endl;
1360 auto end_itor = module->triggers.end();
1361 for (auto itor = module->triggers.begin(); itor != end_itor; ++itor)
1362 {
1363 this->ExportDocComment(module, Keyword::TRIGGERS, std::distance(module->triggers.begin(), itor));
1364
1365 RigDef::Trigger & def = *itor;
1366
1367 m_stream << m_dataline_indentstr
1368 << setw(m_node_id_width) << def.nodes[0].Str() << ", "
1369 << setw(m_node_id_width) << def.nodes[1].Str() << ", "
1370 << setw(m_float_width) << def.contraction_trigger_limit << ", "
1371 << setw(m_float_width) << def.expansion_trigger_limit << ", "
1372 << setw(4) << def.shortbound_trigger_action << ", "
1373 << setw(4) << def.longbound_trigger_action << ", ";
1374
1375 if (BITMASK_IS_1(def.options, Trigger::OPTION_i_INVISIBLE )) { m_stream << (char)TriggerOption::i_INVISIBLE; }
1376 if (BITMASK_IS_1(def.options, Trigger::OPTION_c_COMMAND_STYLE )) { m_stream << (char)TriggerOption::c_COMMAND_STYLE; }
1377 if (BITMASK_IS_1(def.options, Trigger::OPTION_x_START_DISABLED )) { m_stream << (char)TriggerOption::x_START_DISABLED; }
1378 if (BITMASK_IS_1(def.options, Trigger::OPTION_b_KEY_BLOCKER )) { m_stream << (char)TriggerOption::b_KEY_BLOCKER; }
1379 if (BITMASK_IS_1(def.options, Trigger::OPTION_B_TRIGGER_BLOCKER )) { m_stream << (char)TriggerOption::B_TRIGGER_BLOCKER; }
1380 if (BITMASK_IS_1(def.options, Trigger::OPTION_A_INV_TRIGGER_BLOCKER )) { m_stream << (char)TriggerOption::A_INV_TRIGGER_BLOCKER; }
1381 if (BITMASK_IS_1(def.options, Trigger::OPTION_s_CMD_NUM_SWITCH )) { m_stream << (char)TriggerOption::s_CMD_NUM_SWITCH; }
1382 if (BITMASK_IS_1(def.options, Trigger::OPTION_h_UNLOCKS_HOOK_GROUP )) { m_stream << (char)TriggerOption::h_UNLOCKS_HOOK_GROUP; }
1383 if (BITMASK_IS_1(def.options, Trigger::OPTION_H_LOCKS_HOOK_GROUP )) { m_stream << (char)TriggerOption::H_LOCKS_HOOK_GROUP; }
1384 if (BITMASK_IS_1(def.options, Trigger::OPTION_t_CONTINUOUS )) { m_stream << (char)TriggerOption::t_CONTINUOUS; }
1385 if (BITMASK_IS_1(def.options, Trigger::OPTION_E_ENGINE_TRIGGER )) { m_stream << (char)TriggerOption::E_ENGINE_TRIGGER; }
1386
1387 m_stream << " " << def.boundary_timer;
1388 m_stream << endl;
1389 }
1390 m_stream << endl; // Empty line
1391}
1392
1393#define ANIMATOR_ADD_FLAG(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR) \
1394 if (AND_VAR) { m_stream << " | "; } \
1395 if (BITMASK_IS_1((DEF_VAR).flags, RigDef::Animator::BITMASK_CONST)) { \
1396 AND_VAR = true; \
1397 m_stream << NAME_STR; \
1398 }
1399
1400#define ANIMATOR_ADD_AERIAL_FLAG(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR) \
1401 if (AND_VAR) { m_stream << " | "; } \
1402 if (BITMASK_IS_1((DEF_VAR).aero_animator.flags, RigDef::AeroAnimator::BITMASK_CONST)) { \
1403 AND_VAR = true; \
1404 m_stream << NAME_STR << DEF_VAR.aero_animator.engine_idx + 1; \
1405 }
1406
1407#define ANIMATOR_ADD_LIMIT(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR, VALUE) \
1408 if (AND_VAR) { m_stream << " | "; } \
1409 if (BITMASK_IS_1((DEF_VAR).aero_animator.flags, RigDef::Animator::BITMASK_CONST)) { \
1410 AND_VAR = true; \
1411 m_stream << NAME_STR << ": " << VALUE; \
1412 }
1413
1414void Serializer::ProcessAnimators(Document::Module* module)
1415{
1416 if (module->animators.empty())
1417 {
1418 return;
1419 }
1420 m_stream << "animators" << endl << endl;
1421 auto end_itor = module->animators.end();
1422 for (auto itor = module->animators.begin(); itor != end_itor; ++itor)
1423 {
1424 this->ExportDocComment(module, Keyword::ANIMATORS, std::distance(module->animators.begin(), itor));
1425
1426 RigDef::Animator & def = *itor;
1427
1428 m_stream << m_dataline_indentstr
1429 << setw(m_node_id_width) << def.nodes[0].Str() << ", "
1430 << setw(m_node_id_width) << def.nodes[1].Str() << ", "
1431 << setw(m_float_width) << def.lenghtening_factor << ", ";
1432
1433 // Options
1434 bool bAnd = false;
1435 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_VISIBLE , "vis")
1436 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_INVISIBLE , "inv")
1437 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_AIRSPEED , "airspeed")
1438 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_VERTICAL_VELOCITY, "vvi")
1439 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ALTIMETER_100K , "altimeter100k")
1440 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ALTIMETER_10K , "altimeter10k")
1441 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ALTIMETER_1K , "altimeter1k")
1442 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ANGLE_OF_ATTACK , "aoa")
1443 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_FLAP , "flap")
1444 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_AIR_BRAKE , "airbrake")
1445 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ROLL , "roll")
1446 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_PITCH , "pitch")
1447 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_BRAKES , "brakes")
1448 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_ACCEL , "accel")
1449 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_CLUTCH , "clutch")
1450 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_SPEEDO , "speedo")
1451 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_TACHO , "tacho")
1452 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_TURBO , "turbo")
1453 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_PARKING , "parking")
1454 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_SHIFT_LEFT_RIGHT , "shifterman1")
1455 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_SHIFT_BACK_FORTH , "shifterman2")
1456 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_SEQUENTIAL_SHIFT , "sequential")
1457 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_GEAR_SELECT , "shifterlin")
1458 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_TORQUE , "torque")
1459 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_DIFFLOCK , "difflock")
1460 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_BOAT_RUDDER , "rudderboat")
1461 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_BOAT_THROTTLE , "throttleboat")
1462 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_SHORT_LIMIT , "shortlimit")
1463 ANIMATOR_ADD_FLAG(def, bAnd, OPTION_LONG_LIMIT , "longlimit")
1464
1465 ANIMATOR_ADD_AERIAL_FLAG(def, bAnd, OPTION_THROTTLE , "throttle")
1466 ANIMATOR_ADD_AERIAL_FLAG(def, bAnd, OPTION_RPM , "rpm")
1467 ANIMATOR_ADD_AERIAL_FLAG(def, bAnd, OPTION_TORQUE , "aerotorq")
1468 ANIMATOR_ADD_AERIAL_FLAG(def, bAnd, OPTION_PITCH , "aeropit")
1469 ANIMATOR_ADD_AERIAL_FLAG(def, bAnd, OPTION_STATUS , "aerostatus")
1470
1471 ANIMATOR_ADD_LIMIT(def, bAnd, OPTION_SHORT_LIMIT , "shortlimit", def.short_limit)
1472 ANIMATOR_ADD_LIMIT(def, bAnd, OPTION_LONG_LIMIT , "longlimit", def.long_limit)
1473 m_stream << endl;
1474 }
1475 m_stream << endl; // Empty line
1476}
1477
1478void Serializer::ProcessContacters(Document::Module* module)
1479{
1480 if (module->contacters.empty())
1481 {
1482 return;
1483 }
1484 m_stream << "contacters" << endl << endl;
1485
1486 for (RigDef::Node::Ref& node: module->contacters)
1487 {
1488 m_stream << setw(m_node_id_width) << node.Str() << endl;
1489 }
1490
1491 m_stream << endl; // Empty line
1492}
1493
1494void Serializer::ProcessRotators(Document::Module* module)
1495{
1496 if (module->rotators.empty())
1497 {
1498 return;
1499 }
1500 m_stream << "rotators" << endl << endl;
1501 auto end_itor = module->rotators.end();
1502 for (auto itor = module->rotators.begin(); itor != end_itor; ++itor)
1503 {
1504 this->ExportDocComment(module, Keyword::ROTATORS, std::distance(module->rotators.begin(), itor));
1505
1506 Rotator & def = *itor;
1507
1508 // Axis nodes
1509 m_stream
1510 << setw(m_node_id_width) << def.axis_nodes[0].Str() << ", "
1511 << setw(m_node_id_width) << def.axis_nodes[1].Str() << ", ";
1512
1513 // Baseplate nodes
1514 for (int i = 0; i < 4; ++i)
1515 {
1516 m_stream << setw(m_node_id_width) << def.base_plate_nodes[i].Str() << ", ";
1517 }
1518
1519 // Rotating plate nodes
1520 for (int i = 0; i < 4; ++i)
1521 {
1522 m_stream << setw(m_node_id_width) << def.rotating_plate_nodes[i].Str() << ", ";
1523 }
1524
1525 // Attributes
1526 m_stream << setw(m_float_width) << def.rate << ", "
1527 << setw(4) << def.spin_left_key << ", "
1528 << setw(4) << def.spin_right_key << ", ";
1529
1530 // Inertia
1531 m_stream
1532 << setw(m_float_width) << def.inertia.start_delay_factor << ", "
1533 << setw(m_float_width) << def.inertia.stop_delay_factor << ", "
1534 << def.inertia.start_function << ", "
1535 << def.inertia.stop_function << ", "
1536 << def.engine_coupling << ", "
1537 << (def.needs_engine ? "true" : "false");
1538 m_stream << endl;
1539 }
1540 m_stream << endl; // Empty line
1541}
1542
1543void Serializer::ProcessRotators2(Document::Module* module)
1544{
1545 if (module->rotators2.empty())
1546 {
1547 return;
1548 }
1549
1550 // Calc column widths
1551 size_t desc_w = 0, startf_w = 0, stopf_w = 0;
1552 for (RigDef::Rotator2& def: module->rotators2)
1553 {
1554 desc_w = std::max(desc_w, def.description.length());
1555 startf_w = std::max(startf_w, def.inertia.start_function.length());
1556 stopf_w = std::max(stopf_w, def.inertia.stop_function.length());
1557 }
1558
1559 // Write data
1560 m_stream << "rotators2" << endl << endl;
1561 auto end_itor = module->rotators2.end();
1562 for (auto itor = module->rotators2.begin(); itor != end_itor; ++itor)
1563 {
1564 this->ExportDocComment(module, Keyword::ROTATORS, std::distance(module->rotators2.begin(), itor));
1565
1566 Rotator2& def = *itor;
1567 // Axis nodes
1568 m_stream
1569 << setw(m_node_id_width)<< def.axis_nodes[0].Str() << ", "
1570 << setw(m_node_id_width)<< def.axis_nodes[1].Str() << ", ";
1571
1572 // Baseplate nodes
1573 for (int i = 0; i < 4; ++i)
1574 {
1575 m_stream << setw(m_node_id_width) << def.base_plate_nodes[i].Str() << ", ";
1576 }
1577
1578 // Rotating plate nodes
1579 for (int i = 0; i < 4; ++i)
1580 {
1581 m_stream << setw(m_node_id_width) << def.rotating_plate_nodes[i].Str() << ", ";
1582 }
1583
1584 // Attributes
1585 m_stream
1586 << setw(m_float_width) << def.rate << ", "
1587 << def.spin_left_key << ", "
1588 << def.spin_right_key << ", "
1589 << setw(m_float_width) << def.rotating_force << ", "
1590 << setw(m_float_width) << def.tolerance << ", "
1591 << setw(desc_w) << def.description << ", ";
1592
1593 // Inertia
1594 m_stream
1595 << setw(m_float_width) << def.inertia.start_delay_factor << ", "
1596 << setw(m_float_width) << def.inertia.stop_delay_factor << ", "
1597 << setw(startf_w) << def.inertia.start_function << ", "
1598 << setw(stopf_w) << def.inertia.stop_function << ", "
1599 << setw(m_float_width) << def.engine_coupling << ", "
1600 << (def.needs_engine ? "true" : "false");
1601 m_stream << endl;
1602 }
1603 m_stream << endl; // Empty line
1604}
1605
1606void Serializer::ProcessFlexBodyWheels(Document::Module* module)
1607{
1608 if (module->flexbodywheels.empty())
1609 {
1610 return;
1611 }
1612
1613 this->ResetPresets();
1614
1615 m_stream << "flexbodywheels" << endl << endl;
1616 auto end_itor = module->flexbodywheels.end();
1617 for (auto itor = module->flexbodywheels.begin(); itor != end_itor; ++itor)
1618 {
1619 this->UpdatePresets(itor->beam_defaults.get(), itor->node_defaults.get(), nullptr);
1620
1621 this->ExportDocComment(module, Keyword::FLEXBODYWHEELS, std::distance(module->flexbodywheels.begin(), itor));
1622 m_stream << m_dataline_indentstr
1623 << setw(m_float_width) << itor->tyre_radius << ", "
1624 << setw(m_float_width) << itor->rim_radius << ", "
1625 << setw(m_float_width) << itor->width << ", "
1626 << setw(3) << itor->num_rays << ", "
1627 << setw(m_node_id_width) << itor->nodes[0].Str() << ", "
1628 << setw(m_node_id_width) << itor->nodes[1].Str() << ", "
1629 << setw(m_node_id_width) << RigidityNodeToStr(itor->rigidity_node) << ", "
1630 << setw(3) << (int)itor->braking << ", "
1631 << setw(3) << (int)itor->propulsion << ", "
1632 << setw(m_node_id_width) << itor->reference_arm_node.Str() << ", "
1633 << setw(m_float_width) << itor->mass << ", "
1634 << setw(m_float_width) << itor->tyre_springiness << ", "
1635 << setw(m_float_width) << itor->tyre_damping << ", "
1636 << setw(m_float_width) << itor->rim_springiness << ", "
1637 << setw(m_float_width) << itor->rim_damping << ", "
1638 << (static_cast<char>(itor->side)) << ", "
1639 << itor->rim_mesh_name << " " // Separator = space!
1640 << itor->tyre_mesh_name
1641 << endl;
1642 }
1643
1644 m_stream << endl; // Empty line
1645}
1646
1647void Serializer::ProcessTractionControl(Document::Module* module)
1648{
1649 if (module->tractioncontrol.size() == 0) { return; }
1650
1651 RigDef::TractionControl& def = module->tractioncontrol[module->tractioncontrol.size() - 1];
1652
1653 m_stream << "TractionControl "
1654 << setw(m_float_width) << def.regulation_force << ", "
1655 << setw(m_float_width) << def.wheel_slip << ", "
1656 << setw(m_float_width) << def.fade_speed << ", "
1657 << setw(m_float_width) << def.pulse_per_sec << ", "
1658 << "mode: " << (def.attr_is_on ? "ON" : "OFF");
1659
1660 // Modes
1661 if (def.attr_no_dashboard) { m_stream << " & NODASH "; }
1662 if (def.attr_no_toggle) { m_stream << " & NOTOGGLE "; }
1663
1664 m_stream << endl << endl; // Empty line
1665}
1666
1667void Serializer::ProcessBrakes(Document::Module* module)
1668{
1669 if (module->brakes.size() == 0) { return; }
1670
1671 Brakes& brakes = module->brakes[module->brakes.size() - 1];
1672
1673 m_stream << "brakes\n\t"
1674 << setw(m_float_width) << brakes.default_braking_force << ", "
1675 << setw(m_float_width) << brakes.parking_brake_force;
1676
1677 m_stream << endl << endl; // Empty line
1678}
1679
1680void Serializer::ProcessAntiLockBrakes(Document::Module* module)
1681{
1682 if (module->antilockbrakes.size() == 0) { return; }
1683
1684 RigDef::AntiLockBrakes* alb = &module->antilockbrakes[module->antilockbrakes.size() - 1];
1685
1686 m_stream << "AntiLockBrakes "
1687 << setw(m_float_width) << alb->regulation_force << ", "
1688 << setw(m_float_width) << alb->min_speed << ", "
1689 << setw(m_float_width) << alb->pulse_per_sec << ", "
1690 << "mode: " << (alb->attr_is_on ? "ON" : "OFF");
1691 // Modes
1692 if (alb->attr_no_dashboard) { m_stream << " & NODASH "; }
1693 if (alb->attr_no_toggle) { m_stream << " & NOTOGGLE "; }
1694
1695 m_stream << endl << endl; // Empty line
1696}
1697
1698void Serializer::ProcessEngine(Document::Module* module)
1699{
1700 if (module->engine.size() == 0)
1701 {
1702 return;
1703 }
1704
1705 Engine& engine = module->engine[module->engine.size() - 1];
1706
1707 m_stream << "engine"
1708 "\n;\t"
1709 "ShiftDownRPM,"
1710 " ShiftUpRPM,"
1711 " Torque,"
1712 " GlobalGear,"
1713 " ReverseGear,"
1714 " NeutralGear,"
1715 " Forward gears...\n\t"
1716 << setw(12) << engine.shift_down_rpm << ", "
1717 << setw(10) << engine.shift_up_rpm << ", "
1718 << setw(10) << engine.torque << ", "
1719 << setw(10) << engine.global_gear_ratio << ", "
1720 << setw(11) << engine.reverse_gear_ratio << ", "
1721 << setw(11) << engine.neutral_gear_ratio;
1722
1723 auto itor = engine.gear_ratios.begin();
1724 auto end = engine.gear_ratios.end();
1725 for (; itor != end; ++itor)
1726 {
1727 m_stream << ", " << *itor;
1728 }
1729 m_stream << ", -1.0" /*terminator*/ << endl << endl;
1730}
1731
1732void Serializer::ProcessEngoption(Document::Module* module)
1733{
1734 if (module->engoption.size() == 0)
1735 {
1736 return;
1737 }
1738
1739 Engoption& engoption = module->engoption[module->engoption.size() - 1];
1740
1741 m_stream << "engoption"
1742 "\n;\t"
1743 "EngInertia,"
1744 " EngineType,"
1745 " ClutchForce,"
1746 " ShiftTime,"
1747 " ClutchTime,"
1748 " PostShiftTime,"
1749 " StallRPM,"
1750 " IdleRPM,"
1751 " MaxIdleMixture,"
1752 " MinIdleMixture"
1753 " BrakingForce"
1754 "\n\t"
1755 << setw(10) << engoption.inertia << ", "
1756 << setw(10) << (char)engoption.type << ", "
1757 << setw(11) << engoption.clutch_force << ", "
1758 << setw( 9) << engoption.shift_time << ", "
1759 << setw(10) << engoption.clutch_time << ", "
1760 << setw(13) << engoption.post_shift_time << ", "
1761 << setw( 8) << engoption.stall_rpm << ", "
1762 << setw( 7) << engoption.idle_rpm << ", "
1763 << setw(14) << engoption.max_idle_mixture << ", "
1764 << setw(14) << engoption.min_idle_mixture << ", "
1765 << setw(15) << engoption.braking_torque;
1766
1767 m_stream << endl << endl; // Empty line
1768}
1769
1770void Serializer::ProcessHelp(Document::Module* module)
1771{
1772 if (module->help.size() == 0)
1773 {
1774 return;
1775 }
1776 m_stream << "help\n\t" << module->help[module->help.size() - 1].material << endl << endl;
1777}
1778
1779void Serializer::ProcessWheels2(Document::Module* module)
1780{
1781 if (module->wheels2.empty())
1782 {
1783 return;
1784 }
1785
1786 this->ResetPresets();
1787 m_stream << "wheels2" << endl << endl;
1788 auto end_itor = module->wheels2.end();
1789 for (auto itor = module->wheels2.begin(); itor != end_itor; ++itor)
1790 {
1791 this->UpdatePresets(itor->beam_defaults.get(), itor->node_defaults.get(), nullptr);
1792
1793 this->ExportDocComment(module, Keyword::WHEELS2, std::distance(module->wheels2.begin(), itor));
1794 m_stream << m_dataline_indentstr
1795 << setw(m_float_width) << itor->tyre_radius << ", "
1796 << setw(m_float_width) << itor->rim_radius << ", "
1797 << setw(m_float_width) << itor->width << ", "
1798 << setw(3) << itor->num_rays << ", "
1799 << setw(m_node_id_width) << itor->nodes[0].Str() << ", "
1800 << setw(m_node_id_width) << itor->nodes[1].Str() << ", "
1801 << setw(m_node_id_width) << RigidityNodeToStr(itor->rigidity_node) << ", "
1802 << setw(3) << (int)itor->braking << ", "
1803 << setw(3) << (int)itor->propulsion << ", "
1804 << setw(m_node_id_width) << itor->reference_arm_node.Str() << ", "
1805 << setw(m_float_width) << itor->mass << ", "
1806 << setw(m_float_width) << itor->rim_springiness << ", "
1807 << setw(m_float_width) << itor->rim_damping << ", "
1808 << setw(m_float_width) << itor->tyre_springiness << ", "
1809 << setw(m_float_width) << itor->tyre_damping << ", "
1810 << itor->face_material_name << " " // Separator = space!
1811 << itor->band_material_name << " " // Separator = space!
1812 ;
1813 m_stream << endl;
1814 }
1815
1816 m_stream << endl; // Empty line
1817}
1818
1819void Serializer::ProcessWheels(Document::Module* module)
1820{
1821 if (module->wheels.empty())
1822 {
1823 return;
1824 }
1825
1826 this->ResetPresets();
1827 m_stream << "wheels" << endl << endl;
1828 m_stream << ";\t"
1829 << setw(m_float_width) << "radius, "
1830 << setw(m_float_width) << "width, "
1831 << setw(3) << "nrays, "
1832 << setw(m_node_id_width) << "n1, "
1833 << setw(m_node_id_width) << "n2, "
1834 << setw(m_node_id_width) << "snode, "
1835 << setw(3) << "brk, "
1836 << setw(3) << "pwr, "
1837 << setw(m_node_id_width) << "arm, "
1838 << setw(m_float_width) << "mass, "
1839 << setw(m_float_width) << "spring, "
1840 << setw(m_float_width) << "damp, "
1841 << "facemat, "
1842 << "bandmat";
1843
1844 auto end_itor = module->wheels.end();
1845 for (auto itor = module->wheels.begin(); itor != end_itor; ++itor)
1846 {
1847 this->UpdatePresets(itor->beam_defaults.get(), itor->node_defaults.get(), nullptr);
1848
1849 this->ExportDocComment(module, Keyword::WHEELS, std::distance(module->wheels.begin(), itor));
1850 m_stream << m_dataline_indentstr
1851 << setw(m_float_width) << itor->radius << ", "
1852 << setw(m_float_width) << itor->width << ", "
1853 << setw(3) << itor->num_rays << ", "
1854 << setw(m_node_id_width) << itor->nodes[0].Str() << ", "
1855 << setw(m_node_id_width) << itor->nodes[1].Str() << ", "
1856 << setw(m_node_id_width) << RigidityNodeToStr(itor->rigidity_node) << ", "
1857 << setw(3) << (int)itor->braking << ", "
1858 << setw(3) << (int)itor->propulsion << ", "
1859 << setw(m_node_id_width) << itor->reference_arm_node.Str() << ", "
1860 << setw(m_float_width) << itor->mass << ", "
1861 << setw(m_float_width) << itor->springiness << ", "
1862 << setw(m_float_width) << itor->damping << ", "
1863 << itor->face_material_name << " " // Separator = space!
1864 << itor->band_material_name << " " // Separator = space!
1865 ;
1866 m_stream << endl;
1867 }
1868
1869 m_stream << endl; // Empty line
1870}
1871
1872void Serializer::ExportBaseMeshWheel(BaseMeshWheel& def)
1873{
1874 this->UpdatePresets(def.beam_defaults.get(), def.node_defaults.get(), nullptr);
1875
1876 m_stream << m_dataline_indentstr
1877 << setw(m_float_width) << def.tyre_radius << ", "
1878 << setw(m_float_width) << def.rim_radius << ", "
1879 << setw(m_float_width) << def.width << ", "
1880 << setw(3) << def.num_rays << ", "
1881 << setw(m_node_id_width) << def.nodes[0].Str() << ", "
1882 << setw(m_node_id_width) << def.nodes[1].Str() << ", "
1883 << setw(m_node_id_width) << RigidityNodeToStr(def.rigidity_node) << ", "
1884 << setw(3) << (int)def.braking << ", "
1885 << setw(3) << (int)def.propulsion << ", "
1886 << setw(m_node_id_width) << def.reference_arm_node.Str() << ", "
1887 << setw(m_float_width) << def.mass << ", "
1888 << setw(m_float_width) << def.spring << ", "
1889 << setw(m_float_width) << def.damping << ", "
1890 << (static_cast<char>(def.side)) << ", "
1891 << def.mesh_name << " " // Separator = space!
1892 << def.material_name;
1893 m_stream << endl;
1894}
1895
1896void Serializer::ProcessMeshWheels(Document::Module* module)
1897{
1898 if (module->meshwheels.empty()) { return; }
1899
1900 this->ResetPresets();
1901
1902 m_stream << "meshwheels" << "\n\n";
1903
1904 for (MeshWheel& def: module->meshwheels)
1905 {
1906 this->ExportBaseMeshWheel(def);
1907 }
1908
1909 m_stream << endl; // Empty line
1910
1911}
1912
1913void Serializer::ProcessMeshWheels2(Document::Module* module)
1914{
1915 if (module->meshwheels2.empty()) { return; }
1916
1917 this->ResetPresets();
1918
1919 m_stream << "meshwheels2" << "\n\n";
1920
1921 for (MeshWheel2& def: module->meshwheels2)
1922 {
1923 this->ExportBaseMeshWheel(def);
1924 }
1925
1926 m_stream << endl; // Empty line
1927}
1928
1929void Serializer::ProcessCameras(Document::Module* module)
1930{
1931 if (module->cameras.empty())
1932 {
1933 return;
1934 }
1935
1936 m_stream << "cameras\n\n";
1937 for (auto& camera: module->cameras)
1938 {
1939 m_stream
1940 << setw(m_node_id_width) << camera.center_node.Str() << ", "
1941 << setw(m_node_id_width) << camera.back_node.Str() << ", "
1942 << setw(m_node_id_width) << camera.left_node.Str() << "\n";
1943 }
1944 m_stream << "\n";
1945}
1946
1947void Serializer::ProcessCinecam(Document::Module* module)
1948{
1949 if (module->cinecam.empty())
1950 {
1951 return;
1952 }
1953
1954 m_stream << "cinecam" << endl << endl;
1955
1956 for (auto itor = module->cinecam.begin(); itor != module->cinecam.end(); ++itor)
1957 {
1958 this->ExportDocComment(module, Keyword::CINECAM, std::distance(module->cinecam.begin(), itor));
1959 m_stream << m_dataline_indentstr
1960 << setw(m_float_width) << itor->position.x << ", "
1961 << setw(m_float_width) << itor->position.y << ", "
1962 << setw(m_float_width) << itor->position.z << ", ";
1963 m_stream
1964 << setw(m_node_id_width) << itor->nodes[0].Str() << ", "
1965 << setw(m_node_id_width) << itor->nodes[1].Str() << ", "
1966 << setw(m_node_id_width) << itor->nodes[2].Str() << ", "
1967 << setw(m_node_id_width) << itor->nodes[3].Str() << ", "
1968 << setw(m_node_id_width) << itor->nodes[4].Str() << ", "
1969 << setw(m_node_id_width) << itor->nodes[5].Str() << ", "
1970 << setw(m_node_id_width) << itor->nodes[6].Str() << ", "
1971 << setw(m_node_id_width) << itor->nodes[7].Str() << ", ";
1972 m_stream
1973 << setw(m_float_width) << itor->spring << ", "
1974 << setw(m_float_width) << itor->damping
1975 << endl;
1976 }
1977
1978 m_stream << endl; // Empty line
1979}
1980
1981void Serializer::ProcessBeams(Document::Module* module)
1982{
1983 if (module->beams.empty())
1984 {
1985 return;
1986 }
1987
1988 // Write beams to file
1989 m_stream << "beams" << endl << endl;
1990
1991 BeamDefaults* prev_defaults = nullptr;
1992 for (size_t i = 0; i < module->beams.size(); i++)
1993 {
1994 Beam& beam = module->beams[i];
1995 if (prev_defaults != beam.defaults.get())
1996 {
1997 ProcessBeamDefaults(beam.defaults.get());
1998 prev_defaults = beam.defaults.get();
1999 }
2000 this->ExportDocComment(module, Keyword::BEAMS, i);
2001 this->ProcessBeam(beam);
2002 }
2003
2004 // Empty line
2005 m_stream << endl;
2006}
2007
2008void Serializer::ProcessShocks(Document::Module* module)
2009{
2010 if (module->shocks.empty())
2011 {
2012 return;
2013 }
2014
2015 // Write shocks to file
2016 m_stream << "shocks" << endl << endl;
2017
2018 BeamDefaults* prev_defaults = nullptr;
2019 for (size_t i = 0; i < module->shocks.size(); i++)
2020 {
2021 Shock& shock = module->shocks[i];
2022 if (prev_defaults != shock.beam_defaults.get())
2023 {
2024 ProcessBeamDefaults(shock.beam_defaults.get());
2025 prev_defaults = shock.beam_defaults.get();
2026 }
2027 this->ExportDocComment(module, Keyword::SHOCKS, i);
2028 this->ProcessShock(shock);
2029 }
2030
2031 // Empty line
2032 m_stream << endl;
2033}
2034
2035void Serializer::ProcessShocks2(Document::Module* module)
2036{
2037 if (module->shocks2.empty())
2038 {
2039 return;
2040 }
2041
2042 // Write shocks2 to file
2043 m_stream << "shocks2" << endl << endl;
2044
2045 BeamDefaults* prev_defaults = nullptr;
2046 for (size_t i = 0; i < module->shocks2.size(); i++)
2047 {
2048 Shock2& shock2 = module->shocks2[i];
2049 if (prev_defaults != shock2.beam_defaults.get())
2050 {
2051 ProcessBeamDefaults(shock2.beam_defaults.get());
2052 prev_defaults = shock2.beam_defaults.get();
2053 }
2054 this->ExportDocComment(module, Keyword::SHOCKS2, i);
2055 this->ProcessShock2(shock2);
2056 }
2057
2058 // Empty line
2059 m_stream << endl;
2060}
2061
2062void Serializer::ProcessShocks3(Document::Module* module)
2063{
2064 if (module->shocks3.empty())
2065 {
2066 return;
2067 }
2068
2069 // Write shocks3 to file
2070 m_stream << "shocks3" << endl << endl;
2071
2072 BeamDefaults* prev_defaults = nullptr;
2073 for (size_t i = 0; i < module->shocks3.size(); i++)
2074 {
2075 Shock3& shock3 = module->shocks3[i];
2076 if (prev_defaults != shock3.beam_defaults.get())
2077 {
2078 ProcessBeamDefaults(shock3.beam_defaults.get());
2079 prev_defaults = shock3.beam_defaults.get();
2080 }
2081 this->ExportDocComment(module, Keyword::SHOCKS3, i);
2082 this->ProcessShock3(shock3);
2083 }
2084
2085 // Empty line
2086 m_stream << endl;
2087}
2088
2089
2090void Serializer::ProcessHydros(Document::Module* module)
2091{
2092 if (module->hydros.empty())
2093 {
2094 return;
2095 }
2096
2097 // Write hydros to file
2098 m_stream << "hydros" << endl << endl;
2099
2100 BeamDefaults* prev_defaults = nullptr;
2101 for (size_t i = 0; i < module->hydros.size(); i++)
2102 {
2103 Hydro& hydro = module->hydros[i];
2104 if (prev_defaults != hydro.beam_defaults.get())
2105 {
2106 ProcessBeamDefaults(hydro.beam_defaults.get());
2107 prev_defaults = hydro.beam_defaults.get();
2108 }
2109 this->ExportDocComment(module, Keyword::HYDROS, i);
2110 this->ProcessHydro(hydro);
2111 }
2112
2113 // Empty line
2114 m_stream << endl;
2115}
2116
2117void Serializer::ProcessCommands2(Document::Module* module)
2118{
2119 if (module->commands2.empty())
2120 {
2121 return;
2122 }
2123
2124 // Write commands to file
2125 m_stream << "commands" << endl << endl;
2126
2127 BeamDefaults* prev_defaults = nullptr;
2128 for (size_t i = 0; i < module->commands2.size(); i++)
2129 {
2130 Command2& command = module->commands2[i];
2131 if (prev_defaults != command.beam_defaults.get())
2132 {
2133 ProcessBeamDefaults(command.beam_defaults.get());
2134 prev_defaults = command.beam_defaults.get();
2135 }
2136 this->ExportDocComment(module, Keyword::COMMANDS2, i);
2137 this->ProcessCommand2(command);
2138 }
2139
2140 // Empty line
2141 m_stream << endl;
2142}
2143
2144
2145void Serializer::ProcessCommand2(Command2 & def)
2146{
2147 m_stream << m_dataline_indentstr
2148 << std::setw(m_node_id_width) << def.nodes[0].Str() << ", "
2149 << std::setw(m_node_id_width) << def.nodes[1].Str() << ", ";
2150
2151 m_stream << std::setw(m_float_width) << def.shorten_rate << ", ";
2152 m_stream << std::setw(m_float_width) << def.lengthen_rate << ", ";
2153 m_stream << std::setw(m_float_width) << def.max_contraction << ", "; // So-called 'shortbound'
2154 m_stream << std::setw(m_float_width) << def.max_extension << ", "; // So-called 'longbound'
2155 m_stream << std::setw(m_command_key_width) << def.contract_key << ", ";
2156 m_stream << std::setw(m_command_key_width) << def.extend_key << ", ";
2157
2158 // Options
2159 bool dummy = true;
2160 if (def.option_c_auto_center) { m_stream << "c"; dummy = false; }
2161 if (def.option_f_not_faster) { m_stream << "f"; dummy = false; }
2162 if (def.option_i_invisible) { m_stream << "i"; dummy = false; }
2163 if (def.option_o_1press_center) { m_stream << "o"; dummy = false; }
2164 if (def.option_p_1press) { m_stream << "p"; dummy = false; }
2165 if (def.option_r_rope) { m_stream << "r"; dummy = false; }
2166 if (dummy) { m_stream << "n"; } // Placeholder, does nothing
2167
2168 m_stream << ", ";
2169
2170 // Description
2171 m_stream << (def.description.length() > 0 ? def.description : "_");
2172
2173 // Inertia
2174 if (def.inertia.start_function != "" && def.inertia.stop_function != "")
2175 {
2176 m_stream << ", ";
2177 m_stream << std::setw(m_float_width) << def.inertia.start_delay_factor << ", ";
2178 m_stream << std::setw(m_float_width) << def.inertia.stop_delay_factor << ", ";
2179 m_stream << std::setw(m_inertia_function_width) << def.inertia.start_function << ", ";
2180 m_stream << std::setw(m_inertia_function_width) << def.inertia.stop_function << ", ";
2181 m_stream << std::setw(m_float_width) << def.affect_engine << ", ";
2182 m_stream << std::setw(m_bool_width) << (def.needs_engine ? "true" : "false");
2183 }
2184 m_stream << endl;
2185}
2186
2187void Serializer::ProcessHydro(Hydro & def)
2188{
2189 m_stream << m_dataline_indentstr
2190 << std::setw(m_node_id_width) << def.nodes[0].Str() << ", "
2191 << std::setw(m_node_id_width) << def.nodes[1].Str() << ", ";
2192
2193 m_stream << std::setw(m_float_width) << def.lenghtening_factor << ", ";
2194
2195 // Options
2196 if (BITMASK_IS_1(def.options, Hydro::OPTION_j_INVISIBLE )) m_stream << (char)HydroOption::j_INVISIBLE ;
2197 if (BITMASK_IS_1(def.options, Hydro::OPTION_s_DISABLE_ON_HIGH_SPEED )) m_stream << (char)HydroOption::s_DISABLE_ON_HIGH_SPEED ;
2198 if (BITMASK_IS_1(def.options, Hydro::OPTION_a_INPUT_AILERON )) m_stream << (char)HydroOption::a_INPUT_AILERON ;
2199 if (BITMASK_IS_1(def.options, Hydro::OPTION_r_INPUT_RUDDER )) m_stream << (char)HydroOption::r_INPUT_RUDDER ;
2200 if (BITMASK_IS_1(def.options, Hydro::OPTION_e_INPUT_ELEVATOR )) m_stream << (char)HydroOption::e_INPUT_ELEVATOR ;
2201 if (BITMASK_IS_1(def.options, Hydro::OPTION_u_INPUT_AILERON_ELEVATOR )) m_stream << (char)HydroOption::u_INPUT_AILERON_ELEVATOR ;
2202 if (BITMASK_IS_1(def.options, Hydro::OPTION_v_INPUT_InvAILERON_ELEVATOR)) m_stream << (char)HydroOption::v_INPUT_InvAILERON_ELEVATOR;
2203 if (BITMASK_IS_1(def.options, Hydro::OPTION_x_INPUT_AILERON_RUDDER )) m_stream << (char)HydroOption::x_INPUT_AILERON_RUDDER ;
2204 if (BITMASK_IS_1(def.options, Hydro::OPTION_y_INPUT_InvAILERON_RUDDER )) m_stream << (char)HydroOption::y_INPUT_InvAILERON_RUDDER ;
2205 if (BITMASK_IS_1(def.options, Hydro::OPTION_g_INPUT_ELEVATOR_RUDDER )) m_stream << (char)HydroOption::g_INPUT_ELEVATOR_RUDDER ;
2206 if (BITMASK_IS_1(def.options, Hydro::OPTION_h_INPUT_InvELEVATOR_RUDDER )) m_stream << (char)HydroOption::h_INPUT_InvELEVATOR_RUDDER ;
2207 if (BITMASK_IS_1(def.options, Hydro::OPTION_n_INPUT_NORMAL )) m_stream << (char)HydroOption::n_INPUT_NORMAL;
2208 if (def.options == 0) m_stream << (char)HydroOption::n_INPUT_NORMAL;
2209
2210 // Inertia
2211 Inertia & inertia = def.inertia;
2212 if (inertia.start_delay_factor != 0 && inertia.stop_delay_factor != 0)
2213 {
2214 m_stream << ", ";
2215 m_stream << std::setw(m_float_width) << inertia.start_delay_factor << ", ";
2216 m_stream << std::setw(m_float_width) << inertia.stop_delay_factor;
2217 if (!inertia.start_function.empty())
2218 {
2219 m_stream << ", " << std::setw(m_inertia_function_width) << inertia.start_function;
2220 if (!inertia.stop_function.empty())
2221 {
2222 m_stream << ", " << std::setw(m_inertia_function_width) << inertia.stop_function;
2223 }
2224 }
2225 }
2226 m_stream << endl;
2227}
2228
2229void Serializer::ProcessShock(Shock & def)
2230{
2231 m_stream << m_dataline_indentstr
2232 << std::setw(m_node_id_width) << def.nodes[0].Str() << ", "
2233 << std::setw(m_node_id_width) << def.nodes[1].Str() << ", ";
2234 m_stream << std::setw(m_float_width) << def.spring_rate << ", ";
2235 m_stream << std::setw(m_float_width) << def.damping << ", ";
2236 m_stream << std::setw(m_float_width) << def.short_bound << ", ";
2237 m_stream << std::setw(m_float_width) << def.long_bound << ", ";
2238 m_stream << std::setw(m_float_width) << def.precompression << ", ";
2239
2240 // Options
2241 if (def.options == 0)
2242 {
2243 m_stream << "n"; // Placeholder
2244 }
2245 else
2246 {
2247 if (BITMASK_IS_1(def.options, Shock::OPTION_i_INVISIBLE))
2248 {
2249 m_stream << "i";
2250 }
2251 if (BITMASK_IS_1(def.options, Shock::OPTION_m_METRIC))
2252 {
2253 m_stream << "m";
2254 }
2255 if (BITMASK_IS_1(def.options, Shock::OPTION_L_ACTIVE_LEFT))
2256 {
2257 m_stream << "L";
2258 }
2259 if (BITMASK_IS_1(def.options, Shock::OPTION_R_ACTIVE_RIGHT))
2260 {
2261 m_stream << "R";
2262 }
2263 }
2264
2265 // Empty line
2266 m_stream << endl;
2267}
2268
2269void Serializer::ProcessShock2(Shock2 & def)
2270{
2271 m_stream << m_dataline_indentstr
2272 << std::setw(m_node_id_width) << def.nodes[0].Str() << ", "
2273 << std::setw(m_node_id_width) << def.nodes[1].Str() << ", ";
2274
2275 m_stream << std::setw(m_float_width) << def.spring_in << ", ";
2276 m_stream << std::setw(m_float_width) << def.damp_in << ", ";
2277 m_stream << std::setw(m_float_width) << def.progress_factor_spring_in << ", ";
2278 m_stream << std::setw(m_float_width) << def.progress_factor_damp_in << ", ";
2279
2280 m_stream << std::setw(m_float_width) << def.spring_out << ", ";
2281 m_stream << std::setw(m_float_width) << def.damp_out << ", ";
2282 m_stream << std::setw(m_float_width) << def.progress_factor_spring_out << ", ";
2283 m_stream << std::setw(m_float_width) << def.progress_factor_damp_out << ", ";
2284
2285 m_stream << std::setw(m_float_width) << def.short_bound << ", ";
2286 m_stream << std::setw(m_float_width) << def.long_bound << ", ";
2287 m_stream << std::setw(m_float_width) << def.precompression << ", ";
2288
2289 // Options
2290 if (def.options == 0)
2291 {
2292 m_stream << "n"; // Placeholder
2293 }
2294 else
2295 {
2296 if (BITMASK_IS_1(def.options, Shock2::OPTION_i_INVISIBLE))
2297 {
2298 m_stream << "i";
2299 }
2300 if (BITMASK_IS_1(def.options, Shock2::OPTION_m_METRIC))
2301 {
2302 m_stream << "m";
2303 }
2304 if (BITMASK_IS_1(def.options, Shock2::OPTION_M_ABSOLUTE_METRIC))
2305 {
2306 m_stream << "M";
2307 }
2308 if (BITMASK_IS_1(def.options, Shock2::OPTION_s_SOFT_BUMP_BOUNDS))
2309 {
2310 m_stream << "s";
2311 }
2312 }
2313
2314 // Empty line
2315 m_stream << endl;
2316}
2317
2318void Serializer::ProcessShock3(Shock3 & def)
2319{
2320 m_stream << m_dataline_indentstr
2321 << std::setw(m_node_id_width) << def.nodes[0].Str() << ", "
2322 << std::setw(m_node_id_width) << def.nodes[1].Str() << ", ";
2323
2324 m_stream << std::setw(m_float_width) << def.spring_in << ", ";
2325 m_stream << std::setw(m_float_width) << def.damp_in << ", ";
2326 m_stream << std::setw(m_float_width) << def.damp_in_slow << ", ";
2327 m_stream << std::setw(m_float_width) << def.split_vel_in << ", ";
2328 m_stream << std::setw(m_float_width) << def.damp_in_fast << ", ";
2329
2330 m_stream << std::setw(m_float_width) << def.spring_out << ", ";
2331 m_stream << std::setw(m_float_width) << def.damp_out << ", ";
2332 m_stream << std::setw(m_float_width) << def.damp_out_slow << ", ";
2333 m_stream << std::setw(m_float_width) << def.split_vel_out << ", ";
2334 m_stream << std::setw(m_float_width) << def.damp_out_fast << ", ";
2335
2336 m_stream << std::setw(m_float_width) << def.short_bound << ", ";
2337 m_stream << std::setw(m_float_width) << def.long_bound << ", ";
2338 m_stream << std::setw(m_float_width) << def.precompression << ", ";
2339
2340 // Options
2341 if (def.options != 0)
2342 {
2343 m_stream << "n"; // Placeholder
2344 }
2345 else
2346 {
2347 if (BITMASK_IS_1(def.options, Shock3::OPTION_i_INVISIBLE))
2348 {
2349 m_stream << "i";
2350 }
2351 if (BITMASK_IS_1(def.options, Shock3::OPTION_m_METRIC))
2352 {
2353 m_stream << "m";
2354 }
2355 if (BITMASK_IS_1(def.options, Shock3::OPTION_M_ABSOLUTE_METRIC))
2356 {
2357 m_stream << "M";
2358 }
2359 }
2360
2361 // Empty line
2362 m_stream << endl;
2363}
2364
2365void Serializer::ProcessBeamDefaults(BeamDefaults* beam_defaults)
2366{
2367 if (beam_defaults != nullptr)
2368 {
2369 m_stream << fmt::format("{}set_beam_defaults {}, {}, {}, {}, {}, {}, {}\n",
2370 m_setdefaults_indentstr,
2371 (beam_defaults->springiness == DEFAULT_SPRING) ? -1.f : beam_defaults->springiness,
2372 (beam_defaults->damping_constant == DEFAULT_DAMP) ? -1.f : beam_defaults->damping_constant,
2373 (beam_defaults->deformation_threshold == BEAM_DEFORM) ? -1.f : beam_defaults->deformation_threshold,
2374 (beam_defaults->breaking_threshold == BEAM_BREAK) ? -1.f : beam_defaults->breaking_threshold,
2375 beam_defaults->visual_beam_diameter,
2376 beam_defaults->beam_material_name,
2377 beam_defaults->plastic_deform_coef);
2378 }
2379 else
2380 {
2381 m_stream << fmt::format("{}set_beam_defaults {}, {}, {}, {}, {}, {}, {}\n",
2382 m_setdefaults_indentstr, -1, -1, -1, -1, -1, " ", -1);
2383 }
2384}
2385
2386void Serializer::ProcessBeam(Beam & beam)
2387{
2388 m_stream << m_dataline_indentstr
2389 << std::setw(m_node_id_width) << beam.nodes[0].Str() << ", "
2390 << std::setw(m_node_id_width) << beam.nodes[1].Str() << ", ";
2391
2392 // Options
2393 if (beam.options == 0u)
2394 {
2395 m_stream << "n"; // Placeholder
2396 }
2397 else
2398 {
2399 if (BITMASK_IS_1(beam.options, Beam::OPTION_i_INVISIBLE))
2400 {
2401 m_stream << "i";
2402 }
2403 if (BITMASK_IS_1(beam.options, Beam::OPTION_r_ROPE))
2404 {
2405 m_stream << "r";
2406 }
2407 if (BITMASK_IS_1(beam.options, Beam::OPTION_s_SUPPORT))
2408 {
2409 m_stream << "s";
2410 }
2411 }
2412
2413 if (beam._has_extension_break_limit)
2414 {
2415 m_stream << ", " << beam.extension_break_limit;
2416 }
2417
2418 m_stream << endl;
2419}
2420
2421void Serializer::ProcessNodes(Document::Module* module)
2422{
2423 if (module->nodes.empty())
2424 {
2425 return;
2426 }
2427
2428 // Numbered nodes
2429 m_stream << "nodes" << endl << endl;
2430
2431 size_t num_named = 0;
2432 NodeDefaults* prev_preset = nullptr;
2433 DefaultMinimass* prev_dminimass = nullptr;
2434 for (size_t i = 0; i < module->nodes.size(); i++)
2435 {
2436 Node& node = module->nodes[i];
2437 if (node.id.IsTypeNamed())
2438 {
2439 ++num_named;
2440 }
2441
2442 NodeDefaults* preset = node.node_defaults.get();
2443 if (preset != prev_preset)
2444 {
2445 this->ProcessNodeDefaults(preset);
2446 prev_preset = preset;
2447 }
2448
2449 DefaultMinimass* dminimass = node.default_minimass.get();
2450 if (dminimass != prev_dminimass)
2451 {
2452 this->ProcessDefaultMinimass(dminimass);
2453 prev_dminimass = dminimass;
2454 }
2455 this->ExportDocComment(module, Keyword::NODES, i);
2456 this->ProcessNode(node);
2457 }
2458
2459 // Named nodes
2460 if (num_named > 0)
2461 {
2462 m_stream << endl << endl << "nodes2" << endl;
2463
2464 for (size_t i = 0; i < module->nodes.size(); i++)
2465 {
2466 Node& node = module->nodes[i];
2467 if (!node.id.IsTypeNamed())
2468 {
2469 continue;
2470 }
2471
2472 NodeDefaults* preset = node.node_defaults.get();
2473 if (preset != prev_preset)
2474 {
2475 this->ProcessNodeDefaults(preset);
2476 prev_preset = preset;
2477 }
2478
2479 DefaultMinimass* dminimass = node.default_minimass.get();
2480 if (dminimass != prev_dminimass)
2481 {
2482 this->ProcessDefaultMinimass(dminimass);
2483 prev_dminimass = dminimass;
2484 }
2485
2486 this->ExportDocComment(module, Keyword::NODES2, i);
2487 this->ProcessNode(node);
2488 }
2489 }
2490
2491 // Empty line
2492 m_stream << endl;
2493}
2494
2495void Serializer::ProcessNodeDefaults(NodeDefaults* node_defaults)
2496{
2497 if (node_defaults != nullptr)
2498 {
2499 m_stream << fmt::format("{}set_node_defaults {}, {}, {}, {}, {}\n",
2500 m_setdefaults_indentstr,
2501 node_defaults->load_weight,
2502 node_defaults->friction,
2503 node_defaults->volume,
2504 node_defaults->surface,
2505 NodeOptionsToStr(node_defaults->options));
2506 }
2507 else
2508 {
2509 m_stream << fmt::format("{}set_node_defaults {}, {}, {}, {}, {}\n",
2510 m_setdefaults_indentstr, -1, -1, -1, -1, 'n');
2511 }
2512}
2513
2514std::string Serializer::NodeOptionsToStr(BitMask_t options)
2515{
2516 std::string retval;
2517
2518 if (options & Node::OPTION_m_NO_MOUSE_GRAB ) { retval += (char)NodeOption::m_NO_MOUSE_GRAB ; }
2519 if (options & Node::OPTION_f_NO_SPARKS ) { retval += (char)NodeOption::f_NO_SPARKS ; }
2520 if (options & Node::OPTION_x_EXHAUST_POINT ) { retval += (char)NodeOption::x_EXHAUST_POINT ; }
2521 if (options & Node::OPTION_y_EXHAUST_DIRECTION ) { retval += (char)NodeOption::y_EXHAUST_DIRECTION ; }
2522 if (options & Node::OPTION_c_NO_GROUND_CONTACT ) { retval += (char)NodeOption::c_NO_GROUND_CONTACT ; }
2523 if (options & Node::OPTION_h_HOOK_POINT ) { retval += (char)NodeOption::h_HOOK_POINT ; }
2524 if (options & Node::OPTION_e_TERRAIN_EDIT_POINT) { retval += (char)NodeOption::e_TERRAIN_EDIT_POINT; }
2525 if (options & Node::OPTION_b_EXTRA_BUOYANCY ) { retval += (char)NodeOption::b_EXTRA_BUOYANCY ; }
2526 if (options & Node::OPTION_p_NO_PARTICLES ) { retval += (char)NodeOption::p_NO_PARTICLES ; }
2527 if (options & Node::OPTION_L_LOG ) { retval += (char)NodeOption::L_LOG ; }
2528 if (options & Node::OPTION_l_LOAD_WEIGHT ) { retval += (char)NodeOption::l_LOAD_WEIGHT ; }
2529
2530 if (retval == "")
2531 retval += (char)RigDef::NodeOption::n_DUMMY;
2532
2533 return retval;
2534}
2535
2536void Serializer::ProcessDefaultMinimass(DefaultMinimass* def)
2537{
2538 m_stream << fmt::format("{}set_default_minimass {}\n",
2539 m_setdefaults_indentstr,
2540 (def != nullptr) ? def->min_mass_Kg : -1);
2541}
2542
2543void Serializer::ProcessNode(Node & node)
2544{
2545 m_stream << fmt::format("{}{}, {:>{}}, {:>{}}, {:>{}}, {}, {}\n",
2546 m_dataline_indentstr,
2547 node.id.Str(),
2548 node.position.x, m_float_width,
2549 node.position.y, m_float_width,
2550 node.position.z, m_float_width,
2551 NodeOptionsToStr(node.options),
2552 (node._has_load_weight_override) ? fmt::format("{}", node.load_weight_override) : "");
2553}
2554
2555void Serializer::WriteFlags()
2556{
2557 if (m_rig_def->enable_advanced_deformation)
2558 {
2559 m_stream << "enable_advanced_deformation" << endl << endl;
2560 }
2561 if (m_rig_def->hide_in_chooser)
2562 {
2563 m_stream << "hideInChooser" << endl << endl;
2564 }
2565 if (m_rig_def->slide_nodes_connect_instantly)
2566 {
2567 m_stream << "slidenode_connect_instantly" << endl << endl;
2568 }
2569 if (m_rig_def->lockgroup_default_nolock)
2570 {
2571 m_stream << "lockgroup_default_nolock" << endl << endl;
2572 }
2573 if (m_rig_def->rollon)
2574 {
2575 m_stream << "rollon" << endl << endl;
2576 }
2577 if (m_rig_def->rescuer)
2578 {
2579 m_stream << "rescuer" << endl << endl;
2580 }
2581 if (m_rig_def->disable_default_sounds)
2582 {
2583 m_stream << "disabledefaultsounds" << endl << endl;
2584 }
2585 if (m_rig_def->forward_commands)
2586 {
2587 m_stream << "forwardcommands" << endl << endl;
2588 }
2589 if (m_rig_def->import_commands)
2590 {
2591 m_stream << "importcommands" << endl << endl;
2592 }
2593}
2594
2595void Serializer::ProcessFileinfo(Document::Module* module)
2596{
2597 if (module->fileinfo.size() > 0)
2598 {
2599 Fileinfo& data = module->fileinfo[module->fileinfo.size() - 1];
2600
2601 m_stream << "fileinfo ";
2602 m_stream << data.unique_id;
2603 m_stream << ", " << data.category_id;
2604 m_stream << ", " << data.file_version;
2605
2606 m_stream << endl << endl;
2607 }
2608}
2609
2610void Serializer::ProcessGuid(Document::Module* module)
2611{
2612 if (! module->guid.empty())
2613 {
2614 m_stream << "guid " << module->guid[module->guid.size() - 1].guid << endl << endl;
2615 }
2616}
2617
2618void Serializer::ProcessDescription(Document::Module* module)
2619{
2620 if (module->description.size() != 0)
2621 {
2622 m_stream << "description";
2623 for (auto itor = module->description.begin(); itor != module->description.end(); ++itor)
2624 {
2625 std::string line = *itor;
2626 m_stream << endl << line;
2627 }
2628 m_stream << endl << "end_description" << endl << endl;
2629 }
2630}
2631
2632void Serializer::ProcessAuthors(Document::Module* module)
2633{
2634 for (auto itor = module->author.begin(); itor != module->author.end(); ++itor)
2635 {
2636 Author & def = *itor;
2637 m_stream << "author " << def.type << " ";
2638 if (def._has_forum_account)
2639 {
2640 m_stream << def.forum_account_id << " ";
2641 }
2642 else
2643 {
2644 m_stream << "-1 ";
2645 }
2646 m_stream << def.name << " " << def.email << endl;
2647 }
2648 m_stream << endl;
2649}
2650
2651void Serializer::ProcessGlobals(Document::Module* module)
2652{
2653 if (module->globals.size() == 0)
2654 {
2655 return;
2656 }
2657
2658 m_stream << "globals\n\t"
2659 << module->globals[0].dry_mass << ", "
2660 << module->globals[0].cargo_mass;
2661 if (!module->globals[0].material_name.empty())
2662 {
2663 m_stream << ", " << module->globals[0].material_name;
2664 }
2665 m_stream << endl << endl;
2666}
2667
2668void Serializer::ResetPresets()
2669{
2670 m_current_node_defaults = nullptr;
2671 m_current_beam_defaults = nullptr;
2672 m_current_default_minimass = nullptr;
2673}
2674
2675void Serializer::UpdatePresets(BeamDefaults* beam_defaults, NodeDefaults* node_defaults, DefaultMinimass* default_minimass)
2676{
2677 if (m_current_node_defaults != node_defaults)
2678 {
2679 m_current_node_defaults = node_defaults;
2680 this->ProcessNodeDefaults(node_defaults);
2681 }
2682
2683 if (m_current_beam_defaults != beam_defaults)
2684 {
2685 m_current_beam_defaults = beam_defaults;
2686 this->ProcessBeamDefaults(beam_defaults);
2687 }
2688
2689 if (m_current_default_minimass != default_minimass)
2690 {
2691 m_current_default_minimass = default_minimass;
2692 this->ProcessDefaultMinimass(default_minimass);
2693 }
2694}
2695
2696void Serializer::ExportDocComment(Document::Module* module, RigDef::Keyword keyword, ptrdiff_t vectorpos)
2697{
2698 auto itor = std::find_if(module->_comments.begin(), module->_comments.end(),
2699 [keyword, vectorpos](const RigDef::DocComment& dc) { return dc.commented_keyword == keyword && dc.commented_datapos == (int)vectorpos; });
2700
2701 if (itor != module->_comments.end())
2702 {
2703 m_stream << itor->comment_text;
2704 }
2705}
2706
keyword
static int keyword
Definition Bench_TruckParser_IdentifyKeyword.cpp:1448
BITMASK_IS_1
#define BITMASK_IS_1(VAR, FLAGS)
Definition BitFlags.h:14
BitMask_t
uint32_t BitMask_t
Definition BitFlags.h:7
RigDef_File.h
Data structures representing 'truck' file format, see https://docs.rigsofrods.org/vehicle-creation/fi...
ANIMATOR_ADD_FLAG
#define ANIMATOR_ADD_FLAG(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR)
Definition RigDef_Serializer.cpp:1393
PropAnimFlag
void PropAnimFlag(std::stringstream &out, int flags, bool &join, unsigned int mask, const char *name, char joiner='|')
Definition RigDef_Serializer.cpp:631
ANIMATOR_ADD_LIMIT
#define ANIMATOR_ADD_LIMIT(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR, VALUE)
Definition RigDef_Serializer.cpp:1407
ANIMATOR_ADD_AERIAL_FLAG
#define ANIMATOR_ADD_AERIAL_FLAG(DEF_VAR, AND_VAR, BITMASK_CONST, NAME_STR)
Definition RigDef_Serializer.cpp:1400
RigDef_Serializer.h
RigDef::Node::Id::Str
std::string const & Str() const
Definition RigDef_Node.h:61
RigDef::Node::Ref
Legacy parser resolved references on-the-fly and the condition to check named nodes was "are there an...
Definition RigDef_Node.h:78
RigDef::Node::Ref::IsValidAnyState
bool IsValidAnyState() const
Definition RigDef_Node.h:101
RigDef::Node::Ref::Str
std::string const & Str() const
Definition RigDef_Node.h:94
RigDef::Serializer::ProcessRopables
void ProcessRopables(Document::Module *module)
Definition RigDef_Serializer.cpp:1109
RigDef::Serializer::ProcessAntiLockBrakes
void ProcessAntiLockBrakes(Document::Module *module)
Definition RigDef_Serializer.cpp:1680
RigDef::Serializer::ProcessBrakes
void ProcessBrakes(Document::Module *module)
Definition RigDef_Serializer.cpp:1667
RigDef::Serializer::ProcessTurboprops
void ProcessTurboprops(Document::Module *module)
Definition RigDef_Serializer.cpp:277
RigDef::Serializer::ProcessScrewprops
void ProcessScrewprops(Document::Module *module)
Definition RigDef_Serializer.cpp:231
RigDef::Serializer::ProcessShock2
void ProcessShock2(Shock2 &def)
Definition RigDef_Serializer.cpp:2269
RigDef::Serializer::ProcessAuthors
void ProcessAuthors(Document::Module *module)
Definition RigDef_Serializer.cpp:2632
RigDef::Serializer::m_setdefaults_indentstr
std::string m_setdefaults_indentstr
'set_beam_defaults' for example
Definition RigDef_Serializer.h:175
RigDef::Serializer::ProcessExhausts
void ProcessExhausts(Document::Module *module)
Definition RigDef_Serializer.cpp:552
RigDef::Serializer::ProcessDefaultMinimass
void ProcessDefaultMinimass(DefaultMinimass *default_minimass)
Definition RigDef_Serializer.cpp:2536
RigDef::Serializer::ProcessHelp
void ProcessHelp(Document::Module *module)
Definition RigDef_Serializer.cpp:1770
RigDef::Serializer::ProcessDirectiveAddAnimation
void ProcessDirectiveAddAnimation(RigDef::Animation &anim)
Definition RigDef_Serializer.cpp:644
RigDef::Serializer::m_current_node_defaults
NodeDefaults * m_current_node_defaults
Definition RigDef_Serializer.h:178
RigDef::Serializer::ProcessCollisionBoxes
void ProcessCollisionBoxes(Document::Module *module)
Definition RigDef_Serializer.cpp:924
RigDef::Serializer::ExportBaseMeshWheel
void ExportBaseMeshWheel(BaseMeshWheel &def)
Definition RigDef_Serializer.cpp:1872
RigDef::Serializer::ProcessAirbrakes
void ProcessAirbrakes(Document::Module *module)
Definition RigDef_Serializer.cpp:304
RigDef::Serializer::ProcessInterAxles
void ProcessInterAxles(Document::Module *module)
Definition RigDef_Serializer.cpp:984
RigDef::Serializer::ProcessFusedrag
void ProcessFusedrag(Document::Module *module)
Definition RigDef_Serializer.cpp:254
RigDef::Serializer::ProcessSubmeshGroundmodel
void ProcessSubmeshGroundmodel(Document::Module *module)
Definition RigDef_Serializer.cpp:574
RigDef::Serializer::ProcessSoundsources2
void ProcessSoundsources2(Document::Module *module)
Definition RigDef_Serializer.cpp:399
RigDef::Serializer::ProcessRopes
void ProcessRopes(Document::Module *module)
Definition RigDef_Serializer.cpp:1174
RigDef::Serializer::ProcessShocks
void ProcessShocks(Document::Module *)
Definition RigDef_Serializer.cpp:2008
RigDef::Serializer::ProcessNode
void ProcessNode(Node &node)
Definition RigDef_Serializer.cpp:2543
RigDef::Serializer::ProcessNodeDefaults
void ProcessNodeDefaults(NodeDefaults *node_defaults)
Definition RigDef_Serializer.cpp:2495
RigDef::Serializer::ProcessCameras
void ProcessCameras(Document::Module *module)
Definition RigDef_Serializer.cpp:1929
RigDef::Serializer::ProcessMeshWheels2
void ProcessMeshWheels2(Document::Module *module)
Definition RigDef_Serializer.cpp:1913
RigDef::Serializer::ProcessBeam
void ProcessBeam(Beam &beam)
Definition RigDef_Serializer.cpp:2386
RigDef::Serializer::ProcessWings
void ProcessWings(Document::Module *module)
Definition RigDef_Serializer.cpp:338
RigDef::Serializer::ProcessParticles
void ProcessParticles(Document::Module *module)
Definition RigDef_Serializer.cpp:1086
RigDef::Serializer::ProcessGlobals
void ProcessGlobals(Document::Module *module)
Definition RigDef_Serializer.cpp:2651
RigDef::Serializer::RigidityNodeToStr
std::string RigidityNodeToStr(Node::Ref node)
Definition RigDef_Serializer.h:156
RigDef::Serializer::ProcessCinecam
void ProcessCinecam(Document::Module *)
Definition RigDef_Serializer.cpp:1947
RigDef::Serializer::m_current_default_minimass
DefaultMinimass * m_current_default_minimass
Definition RigDef_Serializer.h:179
RigDef::Serializer::ProcessWheels2
void ProcessWheels2(Document::Module *module)
Definition RigDef_Serializer.cpp:1779
RigDef::Serializer::ProcessRailGroups
void ProcessRailGroups(Document::Module *module)
Definition RigDef_Serializer.cpp:1208
RigDef::Serializer::ProcessSubmesh
void ProcessSubmesh(Document::Module *module)
Definition RigDef_Serializer.cpp:584
RigDef::Serializer::ProcessHooks
void ProcessHooks(Document::Module *module)
Definition RigDef_Serializer.cpp:1290
RigDef::Serializer::ProcessWheels
void ProcessWheels(Document::Module *module)
Definition RigDef_Serializer.cpp:1819
RigDef::Serializer::ProcessCommand2
void ProcessCommand2(Command2 &def)
Definition RigDef_Serializer.cpp:2145
RigDef::Serializer::ProcessEngoption
void ProcessEngoption(Document::Module *module)
Definition RigDef_Serializer.cpp:1732
RigDef::Serializer::ProcessPistonprops
void ProcessPistonprops(Document::Module *module)
Definition RigDef_Serializer.cpp:174
RigDef::Serializer::ProcessFileinfo
void ProcessFileinfo(Document::Module *module)
Definition RigDef_Serializer.cpp:2595
RigDef::Serializer::ProcessHydro
void ProcessHydro(Hydro &def)
Definition RigDef_Serializer.cpp:2187
RigDef::Serializer::ProcessShock3
void ProcessShock3(Shock3 &def)
Definition RigDef_Serializer.cpp:2318
RigDef::Serializer::ProcessFlexbodies
void ProcessFlexbodies(Document::Module *module)
Definition RigDef_Serializer.cpp:709
RigDef::Serializer::ProcessContacters
void ProcessContacters(Document::Module *module)
Definition RigDef_Serializer.cpp:1478
RigDef::Serializer::ProcessTriggers
void ProcessTriggers(Document::Module *module)
Definition RigDef_Serializer.cpp:1353
RigDef::Serializer::ProcessBeamDefaults
void ProcessBeamDefaults(BeamDefaults *beam_defaults)
Definition RigDef_Serializer.cpp:2365
RigDef::Serializer::ProcessGuid
void ProcessGuid(Document::Module *module)
Definition RigDef_Serializer.cpp:2610
RigDef::Serializer::ProcessDescription
void ProcessDescription(Document::Module *module)
Definition RigDef_Serializer.cpp:2618
RigDef::Serializer::ProcessCommands2
void ProcessCommands2(Document::Module *)
Definition RigDef_Serializer.cpp:2117
RigDef::Serializer::m_stream
std::stringstream m_stream
Definition RigDef_Serializer.h:166
RigDef::Serializer::ProcessAnimators
void ProcessAnimators(Document::Module *module)
Definition RigDef_Serializer.cpp:1414
RigDef::Serializer::UpdatePresets
void UpdatePresets(BeamDefaults *beam, NodeDefaults *node, DefaultMinimass *minimass)
Definition RigDef_Serializer.cpp:2675
RigDef::Serializer::ProcessCustomDashboardInputs
void ProcessCustomDashboardInputs(Document::Module *module)
Definition RigDef_Serializer.cpp:421
RigDef::Serializer::ProcessTies
void ProcessTies(Document::Module *module)
Definition RigDef_Serializer.cpp:1131
RigDef::Serializer::ProcessShocks3
void ProcessShocks3(Document::Module *)
Definition RigDef_Serializer.cpp:2062
RigDef::Serializer::ProcessFlexBodyWheels
void ProcessFlexBodyWheels(Document::Module *module)
Definition RigDef_Serializer.cpp:1606
RigDef::Serializer::ProcessShock
void ProcessShock(Shock &def)
Definition RigDef_Serializer.cpp:2229
RigDef::Serializer::NodeOptionsToStr
std::string NodeOptionsToStr(BitMask_t options)
Definition RigDef_Serializer.cpp:2514
RigDef::Serializer::ProcessTractionControl
void ProcessTractionControl(Document::Module *module)
Definition RigDef_Serializer.cpp:1647
RigDef::Serializer::ProcessMaterialFlareBindings
void ProcessMaterialFlareBindings(Document::Module *module)
Definition RigDef_Serializer.cpp:822
RigDef::Serializer::ProcessGuiSettings
void ProcessGuiSettings(Document::Module *module)
Definition RigDef_Serializer.cpp:537
RigDef::Serializer::ProcessNodes
void ProcessNodes(Document::Module *)
Definition RigDef_Serializer.cpp:2421
RigDef::Serializer::ProcessMeshWheels
void ProcessMeshWheels(Document::Module *module)
Definition RigDef_Serializer.cpp:1896
RigDef::Serializer::ProcessFixes
void ProcessFixes(Document::Module *module)
Definition RigDef_Serializer.cpp:1159
RigDef::Serializer::ProcessPropsAndAnimations
void ProcessPropsAndAnimations(Document::Module *module)
Definition RigDef_Serializer.cpp:763
RigDef::Serializer::SerializeModule
void SerializeModule(std::shared_ptr< RigDef::Document::Module > m)
Definition RigDef_Serializer.cpp:86
RigDef::Serializer::ProcessHydros
void ProcessHydros(Document::Module *)
Definition RigDef_Serializer.cpp:2090
RigDef::Serializer::ExportDocComment
void ExportDocComment(Document::Module *module, RigDef::Keyword keyword, ptrdiff_t vectorpos)
Definition RigDef_Serializer.cpp:2696
RigDef::Serializer::ProcessSetSkeletonSettings
void ProcessSetSkeletonSettings(Document::Module *module)
Definition RigDef_Serializer.cpp:526
RigDef::Serializer::ProcessTurbojets
void ProcessTurbojets(Document::Module *module)
Definition RigDef_Serializer.cpp:203
RigDef::Serializer::ProcessLockgroups
void ProcessLockgroups(Document::Module *module)
Definition RigDef_Serializer.cpp:1328
RigDef::Serializer::ProcessFlares2
void ProcessFlares2(Document::Module *module)
Definition RigDef_Serializer.cpp:839
RigDef::Serializer::ProcessShocks2
void ProcessShocks2(Document::Module *)
Definition RigDef_Serializer.cpp:2035
RigDef::Serializer::Serializer
Serializer(RigDef::DocumentPtr rig_def)
Definition RigDef_Serializer.cpp:41
RigDef::Serializer::ProcessSoundsources
void ProcessSoundsources(Document::Module *module)
Definition RigDef_Serializer.cpp:379
RigDef::Serializer::ProcessRotators
void ProcessRotators(Document::Module *module)
Definition RigDef_Serializer.cpp:1494
RigDef::Serializer::ProcessBeams
void ProcessBeams(Document::Module *)
Definition RigDef_Serializer.cpp:1981
RigDef::Serializer::m_rig_def
RigDef::DocumentPtr m_rig_def
Definition RigDef_Serializer.h:167
RigDef::Serializer::m_current_beam_defaults
BeamDefaults * m_current_beam_defaults
Definition RigDef_Serializer.h:177
RigDef::Serializer::ProcessManagedMaterialsAndOptions
void ProcessManagedMaterialsAndOptions(Document::Module *module)
Definition RigDef_Serializer.cpp:869
RigDef::Serializer::m_dataline_indentstr
std::string m_dataline_indentstr
a node or a beam line for example
Definition RigDef_Serializer.h:174
RigDef::Serializer::ProcessSpeedLimiter
void ProcessSpeedLimiter(Document::Module *module)
Definition RigDef_Serializer.cpp:1052
RigDef::Serializer::ProcessTorqueCurve
void ProcessTorqueCurve(Document::Module *module)
Definition RigDef_Serializer.cpp:1063
RigDef::Serializer::ProcessVideocamera
void ProcessVideocamera(Document::Module *module)
Definition RigDef_Serializer.cpp:483
RigDef::Serializer::ProcessCruiseControl
void ProcessCruiseControl(Document::Module *module)
Definition RigDef_Serializer.cpp:1036
RigDef::Serializer::ProcessRotators2
void ProcessRotators2(Document::Module *module)
Definition RigDef_Serializer.cpp:1543
RigDef::Serializer::ProcessAxles
void ProcessAxles(Document::Module *module)
Definition RigDef_Serializer.cpp:952
RigDef::Serializer::ProcessSlideNodes
void ProcessSlideNodes(Document::Module *module)
Definition RigDef_Serializer.cpp:1237
RigDef::Serializer::ProcessExtCamera
void ProcessExtCamera(Document::Module *module)
Definition RigDef_Serializer.cpp:458
RigDef::Serializer::ProcessEngine
void ProcessEngine(Document::Module *module)
Definition RigDef_Serializer.cpp:1698
RigDef::Serializer::ProcessTransferCase
void ProcessTransferCase(Document::Module *module)
Definition RigDef_Serializer.cpp:1016
RigDef::Keyword
Keyword
Definition Application.h:180
RigDef::Keyword::COMMANDS2
@ COMMANDS2
RigDef::Keyword::VIDEOCAMERA
@ VIDEOCAMERA
RigDef::Keyword::FLEXBODIES
@ FLEXBODIES
RigDef::Keyword::SHOCKS
@ SHOCKS
RigDef::Keyword::WINGS
@ WINGS
RigDef::Keyword::TIES
@ TIES
RigDef::Keyword::SCREWPROPS
@ SCREWPROPS
RigDef::Keyword::ROTATORS
@ ROTATORS
RigDef::Keyword::AIRBRAKES
@ AIRBRAKES
RigDef::Keyword::PROPS
@ PROPS
RigDef::Keyword::ROPABLES
@ ROPABLES
RigDef::Keyword::ANIMATORS
@ ANIMATORS
RigDef::Keyword::WHEELS
@ WHEELS
RigDef::Keyword::CUSTOMDASHBOARDINPUTS
@ CUSTOMDASHBOARDINPUTS
RigDef::Keyword::SOUNDSOURCES
@ SOUNDSOURCES
RigDef::Keyword::SHOCKS2
@ SHOCKS2
RigDef::Keyword::TURBOJETS
@ TURBOJETS
RigDef::Keyword::SOUNDSOURCES2
@ SOUNDSOURCES2
RigDef::Keyword::FLARES2
@ FLARES2
RigDef::Keyword::EXHAUSTS
@ EXHAUSTS
RigDef::Keyword::AXLES
@ AXLES
RigDef::Keyword::NODES
@ NODES
RigDef::Keyword::TRIGGERS
@ TRIGGERS
RigDef::Keyword::INTERAXLES
@ INTERAXLES
RigDef::Keyword::TURBOPROPS
@ TURBOPROPS
RigDef::Keyword::HOOKS
@ HOOKS
RigDef::Keyword::NODES2
@ NODES2
RigDef::Keyword::PISTONPROPS
@ PISTONPROPS
RigDef::Keyword::RAILGROUPS
@ RAILGROUPS
RigDef::Keyword::SLIDENODES
@ SLIDENODES
RigDef::Keyword::FLEXBODYWHEELS
@ FLEXBODYWHEELS
RigDef::Keyword::SHOCKS3
@ SHOCKS3
RigDef::Keyword::CINECAM
@ CINECAM
RigDef::Keyword::WHEELS2
@ WHEELS2
RigDef::Keyword::BEAMS
@ BEAMS
RigDef::Keyword::HYDROS
@ HYDROS
RigDef::Keyword::ROPES
@ ROPES
RigDef::Keyword::COLLISIONBOXES
@ COLLISIONBOXES
RigDef::Keyword::LOCKGROUPS
@ LOCKGROUPS
RigDef::Keyword::PARTICLES
@ PARTICLES
DEFAULT_SPRING
static const float DEFAULT_SPRING
Definition SimConstants.h:48
BEAM_DEFORM
static const float BEAM_DEFORM
Definition SimConstants.h:61
DEFAULT_DAMP
static const float DEFAULT_DAMP
Definition SimConstants.h:49
BEAM_BREAK
static const float BEAM_BREAK
Definition SimConstants.h:60
RigDef::ROOT_MODULE_NAME
const char * ROOT_MODULE_NAME
Definition RigDef_File.cpp:35
RigDef::TriggerOption::c_COMMAND_STYLE
@ c_COMMAND_STYLE
trigger is set with commandstyle boundaries instead of shocksytle
RigDef::TriggerOption::s_CMD_NUM_SWITCH
@ s_CMD_NUM_SWITCH
switch that exchanges cmdshort/cmdshort for all triggers with the same commandnumbers,...
RigDef::TriggerOption::t_CONTINUOUS
@ t_CONTINUOUS
this trigger sends values between 0 and 1
RigDef::TriggerOption::A_INV_TRIGGER_BLOCKER
@ A_INV_TRIGGER_BLOCKER
Blocker that enable/disable other triggers, reversed activation method (inverted Blocker style,...
RigDef::TriggerOption::B_TRIGGER_BLOCKER
@ B_TRIGGER_BLOCKER
Blocker that enable/disable other triggers.
RigDef::TriggerOption::E_ENGINE_TRIGGER
@ E_ENGINE_TRIGGER
this trigger is used to control an engine
RigDef::TriggerOption::x_START_DISABLED
@ x_START_DISABLED
this trigger is disabled on startup, default is enabled
RigDef::TriggerOption::b_KEY_BLOCKER
@ b_KEY_BLOCKER
Set the CommandKeys that are set in a commandkeyblocker or trigger to blocked on startup,...
RigDef::DocumentPtr
std::shared_ptr< Document > DocumentPtr
Definition ForwardDeclarations.h:293
RigDef::Airbrake::aditional_node
Node::Ref aditional_node
Definition RigDef_File.h:329
RigDef::Airbrake::y_axis_node
Node::Ref y_axis_node
Definition RigDef_File.h:328
RigDef::Airbrake::reference_node
Node::Ref reference_node
Definition RigDef_File.h:326
RigDef::Airbrake::max_inclination_angle
float max_inclination_angle
Definition RigDef_File.h:333
RigDef::Airbrake::x_axis_node
Node::Ref x_axis_node
Definition RigDef_File.h:327
RigDef::Airbrake::offset
Ogre::Vector3 offset
Definition RigDef_File.h:330
RigDef::Animation::SOURCE_TURBO
static const BitMask64_t SOURCE_TURBO
Definition RigDef_File.h:374
RigDef::Animation::SOURCE_SEQUENTIAL_SHIFT
static const BitMask64_t SOURCE_SEQUENTIAL_SHIFT
Definition RigDef_File.h:378
RigDef::Animation::SOURCE_AIR_RUDDER
static const BitMask64_t SOURCE_AIR_RUDDER
Definition RigDef_File.h:388
RigDef::Animation::MODE_ROTATION_X
static const BitMask_t MODE_ROTATION_X
Definition RigDef_File.h:398
RigDef::Animation::SOURCE_ALTIMETER_1K
static const BitMask64_t SOURCE_ALTIMETER_1K
Definition RigDef_File.h:363
RigDef::Animation::MODE_OFFSET_Y
static const BitMask_t MODE_OFFSET_Y
Definition RigDef_File.h:402
RigDef::Animation::SOURCE_SHIFT_LEFT_RIGHT
static const BitMask64_t SOURCE_SHIFT_LEFT_RIGHT
Definition RigDef_File.h:376
RigDef::Animation::MODE_NO_FLIP
static const BitMask_t MODE_NO_FLIP
Definition RigDef_File.h:405
RigDef::Animation::SOURCE_FLAP
static const BitMask64_t SOURCE_FLAP
Definition RigDef_File.h:365
RigDef::Animation::SOURCE_SPEEDO
static const BitMask64_t SOURCE_SPEEDO
Definition RigDef_File.h:372
RigDef::Animation::SOURCE_DIFFLOCK
static const BitMask64_t SOURCE_DIFFLOCK
Definition RigDef_File.h:382
RigDef::Animation::SOURCE_ALTIMETER_10K
static const BitMask64_t SOURCE_ALTIMETER_10K
Definition RigDef_File.h:362
RigDef::Animation::SOURCE_AIRSPEED
static const BitMask64_t SOURCE_AIRSPEED
Definition RigDef_File.h:359
RigDef::Animation::source
BitMask64_t source
Definition RigDef_File.h:412
RigDef::Animation::MODE_AUTO_ANIMATE
static const BitMask_t MODE_AUTO_ANIMATE
Definition RigDef_File.h:404
RigDef::Animation::SOURCE_ROLL
static const BitMask64_t SOURCE_ROLL
Definition RigDef_File.h:367
RigDef::Animation::SOURCE_BOAT_THROTTLE
static const BitMask64_t SOURCE_BOAT_THROTTLE
Definition RigDef_File.h:384
RigDef::Animation::SOURCE_CLUTCH
static const BitMask64_t SOURCE_CLUTCH
Definition RigDef_File.h:371
RigDef::Animation::MODE_OFFSET_Z
static const BitMask_t MODE_OFFSET_Z
Definition RigDef_File.h:403
RigDef::Animation::SOURCE_PITCH
static const BitMask64_t SOURCE_PITCH
Definition RigDef_File.h:368
RigDef::Animation::SOURCE_TACHO
static const BitMask64_t SOURCE_TACHO
Definition RigDef_File.h:373
RigDef::Animation::SOURCE_AILERON
static const BitMask64_t SOURCE_AILERON
Definition RigDef_File.h:386
RigDef::Animation::MODE_ROTATION_Y
static const BitMask_t MODE_ROTATION_Y
Definition RigDef_File.h:399
RigDef::Animation::SOURCE_ELEVATOR
static const BitMask64_t SOURCE_ELEVATOR
Definition RigDef_File.h:387
RigDef::Animation::SOURCE_PERMANENT
static const BitMask64_t SOURCE_PERMANENT
Definition RigDef_File.h:389
RigDef::Animation::MODE_EVENT_LOCK
static const BitMask_t MODE_EVENT_LOCK
Definition RigDef_File.h:407
RigDef::Animation::event_name
Ogre::String event_name
Definition RigDef_File.h:415
RigDef::Animation::SOURCE_STEERING_WHEEL
static const BitMask64_t SOURCE_STEERING_WHEEL
Definition RigDef_File.h:385
RigDef::Animation::SOURCE_PARKING
static const BitMask64_t SOURCE_PARKING
Definition RigDef_File.h:375
RigDef::Animation::SOURCE_SHIFT_BACK_FORTH
static const BitMask64_t SOURCE_SHIFT_BACK_FORTH
Definition RigDef_File.h:377
RigDef::Animation::SOURCE_ACCEL
static const BitMask64_t SOURCE_ACCEL
Definition RigDef_File.h:370
RigDef::Animation::SOURCE_AIR_BRAKE
static const BitMask64_t SOURCE_AIR_BRAKE
Definition RigDef_File.h:366
RigDef::Animation::SOURCE_ANGLE_OF_ATTACK
static const BitMask64_t SOURCE_ANGLE_OF_ATTACK
Definition RigDef_File.h:364
RigDef::Animation::SOURCE_VERTICAL_VELOCITY
static const BitMask64_t SOURCE_VERTICAL_VELOCITY
Definition RigDef_File.h:360
RigDef::Animation::MODE_OFFSET_X
static const BitMask_t MODE_OFFSET_X
Definition RigDef_File.h:401
RigDef::Animation::MODE_BOUNCE
static const BitMask_t MODE_BOUNCE
Definition RigDef_File.h:406
RigDef::Animation::SOURCE_SHIFTERLIN
static const BitMask64_t SOURCE_SHIFTERLIN
Definition RigDef_File.h:379
RigDef::Animation::SOURCE_ALTIMETER_100K
static const BitMask64_t SOURCE_ALTIMETER_100K
Definition RigDef_File.h:361
RigDef::Animation::SOURCE_BOAT_RUDDER
static const BitMask64_t SOURCE_BOAT_RUDDER
Definition RigDef_File.h:383
RigDef::Animation::SOURCE_BRAKES
static const BitMask64_t SOURCE_BRAKES
Definition RigDef_File.h:369
RigDef::Animation::SOURCE_TORQUE
static const BitMask64_t SOURCE_TORQUE
Definition RigDef_File.h:380
RigDef::Animation::MODE_ROTATION_Z
static const BitMask_t MODE_ROTATION_Z
Definition RigDef_File.h:400
RigDef::Animation::SOURCE_EVENT
static const BitMask64_t SOURCE_EVENT
Definition RigDef_File.h:390
RigDef::Animation::SOURCE_HEADING
static const BitMask64_t SOURCE_HEADING
Definition RigDef_File.h:381
RigDef::Animator::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:453
RigDef::Author::name
Ogre::String name
Definition RigDef_File.h:480
RigDef::Author::forum_account_id
unsigned int forum_account_id
Definition RigDef_File.h:479
RigDef::Author::_has_forum_account
bool _has_forum_account
Definition RigDef_File.h:482
RigDef::Author::type
Ogre::String type
Definition RigDef_File.h:478
RigDef::Author::email
Ogre::String email
Definition RigDef_File.h:481
RigDef::Axle::options
DifferentialTypeVec options
Order matters!
Definition RigDef_File.h:488
RigDef::Axle::wheels
Node::Ref wheels[2][2]
Definition RigDef_File.h:487
RigDef::BaseMeshWheel::material_name
Ogre::String material_name
Definition RigDef_File.h:283
RigDef::BaseMeshWheel::side
RoR::WheelSide side
Definition RigDef_File.h:281
RigDef::BaseMeshWheel::mesh_name
Ogre::String mesh_name
Definition RigDef_File.h:282
RigDef::BaseWheel::braking
RoR::WheelBraking braking
Definition RigDef_File.h:271
RigDef::BaseWheel::num_rays
unsigned int num_rays
Definition RigDef_File.h:268
RigDef::BaseWheel::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:276
RigDef::BaseWheel::node_defaults
std::shared_ptr< NodeDefaults > node_defaults
Definition RigDef_File.h:275
RigDef::BaseWheel::rigidity_node
Node::Ref rigidity_node
Definition RigDef_File.h:270
RigDef::BaseWheel::propulsion
RoR::WheelPropulsion propulsion
Definition RigDef_File.h:272
RigDef::BaseWheel::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:269
RigDef::BaseWheel::reference_arm_node
Node::Ref reference_arm_node
Definition RigDef_File.h:273
RigDef::BeamDefaults::beam_material_name
Ogre::String beam_material_name
Definition RigDef_File.h:559
RigDef::Beam::OPTION_r_ROPE
static const BitMask_t OPTION_r_ROPE
Definition RigDef_File.h:494
RigDef::Beam::options
BitMask_t options
Definition RigDef_File.h:498
RigDef::Beam::_has_extension_break_limit
bool _has_extension_break_limit
Definition RigDef_File.h:500
RigDef::Beam::defaults
std::shared_ptr< BeamDefaults > defaults
Definition RigDef_File.h:502
RigDef::Beam::extension_break_limit
float extension_break_limit
Definition RigDef_File.h:499
RigDef::Beam::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:493
RigDef::Beam::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:497
RigDef::Beam::OPTION_s_SUPPORT
static const BitMask_t OPTION_s_SUPPORT
Definition RigDef_File.h:495
RigDef::Brakes::default_braking_force
float default_braking_force
Definition RigDef_File.h:569
RigDef::Brakes::parking_brake_force
float parking_brake_force
Definition RigDef_File.h:570
RigDef::Cab::OPTION_r_BUOYANT_ONLY_DRAG
static const BitMask_t OPTION_r_BUOYANT_ONLY_DRAG
Definition RigDef_File.h:580
RigDef::Cab::OPTION_p_10xTOUGHER
static const BitMask_t OPTION_p_10xTOUGHER
Definition RigDef_File.h:577
RigDef::Cab::OPTION_s_BUOYANT_NO_DRAG
static const BitMask_t OPTION_s_BUOYANT_NO_DRAG
Definition RigDef_File.h:579
RigDef::Cab::OPTION_F_10xTOUGHER_BUOYANT
static const BitMask_t OPTION_F_10xTOUGHER_BUOYANT
Definition RigDef_File.h:582
RigDef::Cab::OPTION_b_BUOYANT
static const BitMask_t OPTION_b_BUOYANT
Definition RigDef_File.h:576
RigDef::Cab::OPTION_D_CONTACT_BUOYANT
static const BitMask_t OPTION_D_CONTACT_BUOYANT
Definition RigDef_File.h:581
RigDef::Cab::OPTION_S_INVULNERABLE_BUOYANT
static const BitMask_t OPTION_S_INVULNERABLE_BUOYANT
Definition RigDef_File.h:583
RigDef::Cab::OPTION_c_CONTACT
static const BitMask_t OPTION_c_CONTACT
Definition RigDef_File.h:575
RigDef::Cab::OPTION_u_INVULNERABLE
static const BitMask_t OPTION_u_INVULNERABLE
Definition RigDef_File.h:578
RigDef::CollisionBox::nodes
std::vector< Node::Ref > nodes
Definition RigDef_File.h:619
RigDef::Command2::description
Ogre::String description
Definition RigDef_File.h:636
RigDef::Command2::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:629
RigDef::Command2::extend_key
RoR::CommandkeyID_t extend_key
Definition RigDef_File.h:635
RigDef::Command2::contract_key
RoR::CommandkeyID_t contract_key
Definition RigDef_File.h:634
RigDef::Command2::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:641
RigDef::Command2::option_o_1press_center
bool option_o_1press_center
Definition RigDef_File.h:650
RigDef::DefaultMinimass::min_mass_Kg
float min_mass_Kg
minimum node mass in Kg
Definition RigDef_File.h:667
RigDef::DocComment
< Represents a comment (line starting with ';' or '//') that can be anywhere in the file.
Definition RigDef_File.h:312
RigDef::Document::Module::fixes
std::vector< Node::Ref > fixes
Definition RigDef_File.h:1401
RigDef::Document::Module::wheels2
std::vector< Wheel2 > wheels2
Definition RigDef_File.h:1454
RigDef::Document::Module::exhausts
std::vector< Exhaust > exhausts
Definition RigDef_File.h:1398
RigDef::Document::Module::ropables
std::vector< Ropable > ropables
Definition RigDef_File.h:1427
RigDef::Document::Module::props
std::vector< Prop > props
Definition RigDef_File.h:1425
RigDef::Document::Module::collisionboxes
std::vector< CollisionBox > collisionboxes
Definition RigDef_File.h:1387
RigDef::Document::Module::interaxles
std::vector< InterAxle > interaxles
Definition RigDef_File.h:1415
RigDef::Document::Module::rotators2
std::vector< Rotator2 > rotators2
Definition RigDef_File.h:1430
RigDef::Document::Module::soundsources2
std::vector< SoundSource2 > soundsources2
Definition RigDef_File.h:1440
RigDef::Document::Module::rotators
std::vector< Rotator > rotators
Definition RigDef_File.h:1429
RigDef::Document::Module::set_skeleton_settings
std::vector< SkeletonSettings > set_skeleton_settings
Definition RigDef_File.h:1437
RigDef::Document::Module::submesh_groundmodel
std::vector< Ogre::String > submesh_groundmodel
Definition RigDef_File.h:1442
RigDef::Document::Module::wings
std::vector< Wing > wings
Definition RigDef_File.h:1455
RigDef::Document::Module::customdashboardinputs
std::vector< CustomDashboardInput > customdashboardinputs
Definition RigDef_File.h:1392
RigDef::Document::Module::guisettings
std::vector< GuiSettings > guisettings
Definition RigDef_File.h:1411
RigDef::Document::Module::antilockbrakes
std::vector< AntiLockBrakes > antilockbrakes
Definition RigDef_File.h:1379
RigDef::Document::Module::_comments
std::vector< DocComment > _comments
Definition RigDef_File.h:1462
RigDef::Document::Module::description
std::vector< Ogre::String > description
Definition RigDef_File.h:1394
RigDef::Document::Module::meshwheels2
std::vector< MeshWheel2 > meshwheels2
Definition RigDef_File.h:1420
RigDef::Document::Module::turbojets
std::vector< Turbojet > turbojets
Definition RigDef_File.h:1449
RigDef::Document::Module::particles
std::vector< Particle > particles
Definition RigDef_File.h:1423
RigDef::Document::Module::videocameras
std::vector< VideoCamera > videocameras
Definition RigDef_File.h:1451
RigDef::Document::Module::shocks
std::vector< Shock > shocks
Definition RigDef_File.h:1433
RigDef::Document::Module::cruisecontrol
std::vector< CruiseControl > cruisecontrol
Definition RigDef_File.h:1390
RigDef::Document::Module::shocks2
std::vector< Shock2 > shocks2
Definition RigDef_File.h:1434
RigDef::Document::Module::ties
std::vector< Tie > ties
Definition RigDef_File.h:1444
RigDef::Document::Module::hooks
std::vector< Hook > hooks
Definition RigDef_File.h:1413
RigDef::Document::Module::pistonprops
std::vector< Pistonprop > pistonprops
Definition RigDef_File.h:1424
RigDef::Document::Module::tractioncontrol
std::vector< TractionControl > tractioncontrol
Definition RigDef_File.h:1446
RigDef::Document::Module::author
std::vector< Author > author
Definition RigDef_File.h:1381
RigDef::Document::Module::meshwheels
std::vector< MeshWheel > meshwheels
Definition RigDef_File.h:1419
RigDef::Document::Module::animators
std::vector< Animator > animators
Definition RigDef_File.h:1378
RigDef::Document::Module::soundsources
std::vector< SoundSource > soundsources
Definition RigDef_File.h:1439
RigDef::Document::Module::cinecam
std::vector< Cinecam > cinecam
Definition RigDef_File.h:1388
RigDef::Document::Module::managedmaterials
std::vector< ManagedMaterial > managedmaterials
Definition RigDef_File.h:1417
RigDef::Document::Module::speedlimiter
std::vector< SpeedLimiter > speedlimiter
Definition RigDef_File.h:1441
RigDef::Document::Module::flexbodywheels
std::vector< FlexBodyWheel > flexbodywheels
Definition RigDef_File.h:1407
RigDef::Document::Module::transfercase
std::vector< TransferCase > transfercase
Definition RigDef_File.h:1447
RigDef::Document::Module::flexbodies
std::vector< Flexbody > flexbodies
Definition RigDef_File.h:1406
RigDef::Document::Module::globals
std::vector< Globals > globals
Definition RigDef_File.h:1409
RigDef::Document::Module::lockgroups
std::vector< Lockgroup > lockgroups
Definition RigDef_File.h:1416
RigDef::Document::Module::nodes
std::vector< Node > nodes
Definition RigDef_File.h:1422
RigDef::Document::Module::ropes
std::vector< Rope > ropes
Definition RigDef_File.h:1428
RigDef::Document::Module::contacters
std::vector< Node::Ref > contacters
Definition RigDef_File.h:1391
RigDef::Document::Module::wheels
std::vector< Wheel > wheels
Definition RigDef_File.h:1453
RigDef::Document::Module::engoption
std::vector< Engoption > engoption
Definition RigDef_File.h:1396
RigDef::Document::Module::commands2
std::vector< Command2 > commands2
Definition RigDef_File.h:1389
RigDef::Document::Module::torquecurve
std::vector< TorqueCurve > torquecurve
Definition RigDef_File.h:1445
RigDef::Document::Module::triggers
std::vector< Trigger > triggers
Definition RigDef_File.h:1448
RigDef::Document::Module::materialflarebindings
std::vector< MaterialFlareBinding > materialflarebindings
Definition RigDef_File.h:1418
RigDef::Document::Module::extcamera
std::vector< ExtCamera > extcamera
Definition RigDef_File.h:1399
RigDef::Document::Module::turboprops2
std::vector< Turboprop2 > turboprops2
Definition RigDef_File.h:1450
RigDef::Document::Module::railgroups
std::vector< RailGroup > railgroups
Definition RigDef_File.h:1426
RigDef::Document::Module::fileinfo
std::vector< Fileinfo > fileinfo
Definition RigDef_File.h:1402
RigDef::Document::Module::engine
std::vector< Engine > engine
Definition RigDef_File.h:1395
RigDef::Document::Module::axles
std::vector< Axle > axles
Definition RigDef_File.h:1382
RigDef::Document::Module::shocks3
std::vector< Shock3 > shocks3
Definition RigDef_File.h:1435
RigDef::Document::Module::hydros
std::vector< Hydro > hydros
Definition RigDef_File.h:1414
RigDef::Document::Module::screwprops
std::vector< Screwprop > screwprops
Definition RigDef_File.h:1431
RigDef::Document::Module::slidenodes
std::vector< SlideNode > slidenodes
Definition RigDef_File.h:1438
RigDef::Document::Module::beams
std::vector< Beam > beams
Definition RigDef_File.h:1383
RigDef::Document::Module::brakes
std::vector< Brakes > brakes
Definition RigDef_File.h:1384
RigDef::Document::Module::cameras
std::vector< Camera > cameras
Definition RigDef_File.h:1385
RigDef::Document::Module::help
std::vector< Help > help
Definition RigDef_File.h:1412
RigDef::Document::Module::flares2
std::vector< Flare2 > flares2
Definition RigDef_File.h:1403
RigDef::Document::Module::airbrakes
std::vector< Airbrake > airbrakes
Definition RigDef_File.h:1377
RigDef::Document::Module::guid
std::vector< Guid > guid
Definition RigDef_File.h:1410
RigDef::Engine::gear_ratios
std::vector< float > gear_ratios
Definition RigDef_File.h:683
RigDef::Engine::global_gear_ratio
float global_gear_ratio
Definition RigDef_File.h:680
RigDef::Engine::neutral_gear_ratio
float neutral_gear_ratio
Definition RigDef_File.h:682
RigDef::Engine::reverse_gear_ratio
float reverse_gear_ratio
Definition RigDef_File.h:681
RigDef::Engoption::shift_time
float shift_time
Seconds.
Definition RigDef_File.h:691
RigDef::Engoption::post_shift_time
float post_shift_time
Seconds.
Definition RigDef_File.h:693
RigDef::Engoption::clutch_time
float clutch_time
Seconds.
Definition RigDef_File.h:692
RigDef::Exhaust::direction_node
Node::Ref direction_node
Definition RigDef_File.h:724
RigDef::Exhaust::reference_node
Node::Ref reference_node
Definition RigDef_File.h:723
RigDef::Exhaust::particle_name
Ogre::String particle_name
Definition RigDef_File.h:725
RigDef::ExtCamera::mode
RoR::ExtCameraMode mode
Definition RigDef_File.h:730
RigDef::Fileinfo::unique_id
Ogre::String unique_id
Definition RigDef_File.h:741
RigDef::FlareBase::type
RoR::FlareType type
Definition RigDef_File.h:752
RigDef::FlareBase::material_name
Ogre::String material_name
Definition RigDef_File.h:757
RigDef::FlareBase::node_axis_x
Node::Ref node_axis_x
Definition RigDef_File.h:749
RigDef::FlareBase::reference_node
Node::Ref reference_node
Definition RigDef_File.h:748
RigDef::FlareBase::offset
Ogre::Vector3 offset
Definition RigDef_File.h:751
RigDef::FlareBase::control_number
int control_number
Only 'u' type flares.
Definition RigDef_File.h:753
RigDef::FlareBase::node_axis_y
Node::Ref node_axis_y
Definition RigDef_File.h:750
RigDef::Flexbody::mesh_name
Ogre::String mesh_name
Definition RigDef_File.h:792
RigDef::Flexbody::y_axis_node
Node::Ref y_axis_node
Definition RigDef_File.h:789
RigDef::Flexbody::rotation
Ogre::Vector3 rotation
Definition RigDef_File.h:791
RigDef::Flexbody::animations
std::list< Animation > animations
Definition RigDef_File.h:793
RigDef::Flexbody::offset
Ogre::Vector3 offset
Definition RigDef_File.h:790
RigDef::Flexbody::reference_node
Node::Ref reference_node
Definition RigDef_File.h:787
RigDef::Flexbody::x_axis_node
Node::Ref x_axis_node
Definition RigDef_File.h:788
RigDef::Flexbody::node_list
std::vector< Node::Ref > node_list
Definition RigDef_File.h:795
RigDef::Hook::node
Node::Ref node
Definition RigDef_File.h:848
RigDef::Hook::option_max_force
float option_max_force
Definition RigDef_File.h:851
RigDef::Hook::flag_no_disable
bool flag_no_disable
Definition RigDef_File.h:858
RigDef::Hook::flag_self_lock
bool flag_self_lock
Definition RigDef_File.h:856
RigDef::Hook::option_timer
float option_timer
Definition RigDef_File.h:854
RigDef::Hook::option_speed_coef
float option_speed_coef
Definition RigDef_File.h:850
RigDef::Hook::flag_auto_lock
bool flag_auto_lock
Definition RigDef_File.h:857
RigDef::Hook::option_hook_range
float option_hook_range
Definition RigDef_File.h:849
RigDef::Hook::option_min_range_meters
float option_min_range_meters
Definition RigDef_File.h:855
RigDef::Hydro::OPTION_e_INPUT_ELEVATOR
static const BitMask_t OPTION_e_INPUT_ELEVATOR
Definition RigDef_File.h:871
RigDef::Hydro::lenghtening_factor
float lenghtening_factor
Definition RigDef_File.h:882
RigDef::Hydro::OPTION_s_DISABLE_ON_HIGH_SPEED
static const BitMask_t OPTION_s_DISABLE_ON_HIGH_SPEED
Definition RigDef_File.h:867
RigDef::Hydro::options
BitMask_t options
Definition RigDef_File.h:883
RigDef::Hydro::OPTION_h_INPUT_InvELEVATOR_RUDDER
static const BitMask_t OPTION_h_INPUT_InvELEVATOR_RUDDER
Definition RigDef_File.h:877
RigDef::Hydro::OPTION_g_INPUT_ELEVATOR_RUDDER
static const BitMask_t OPTION_g_INPUT_ELEVATOR_RUDDER
Definition RigDef_File.h:876
RigDef::Hydro::OPTION_y_INPUT_InvAILERON_RUDDER
static const BitMask_t OPTION_y_INPUT_InvAILERON_RUDDER
Definition RigDef_File.h:875
RigDef::Hydro::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:881
RigDef::Hydro::OPTION_j_INVISIBLE
static const BitMask_t OPTION_j_INVISIBLE
Definition RigDef_File.h:865
RigDef::Hydro::OPTION_v_INPUT_InvAILERON_ELEVATOR
static const BitMask_t OPTION_v_INPUT_InvAILERON_ELEVATOR
Definition RigDef_File.h:873
RigDef::Hydro::OPTION_a_INPUT_AILERON
static const BitMask_t OPTION_a_INPUT_AILERON
Definition RigDef_File.h:869
RigDef::Hydro::OPTION_r_INPUT_RUDDER
static const BitMask_t OPTION_r_INPUT_RUDDER
Definition RigDef_File.h:870
RigDef::Hydro::OPTION_n_INPUT_NORMAL
static const BitMask_t OPTION_n_INPUT_NORMAL
Definition RigDef_File.h:879
RigDef::Hydro::OPTION_u_INPUT_AILERON_ELEVATOR
static const BitMask_t OPTION_u_INPUT_AILERON_ELEVATOR
Definition RigDef_File.h:872
RigDef::Hydro::inertia
Inertia inertia
Definition RigDef_File.h:884
RigDef::Hydro::OPTION_x_INPUT_AILERON_RUDDER
static const BitMask_t OPTION_x_INPUT_AILERON_RUDDER
Definition RigDef_File.h:874
RigDef::Hydro::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:886
RigDef::Inertia::start_function
Ogre::String start_function
Definition RigDef_File.h:307
RigDef::Inertia::start_delay_factor
float start_delay_factor
Definition RigDef_File.h:305
RigDef::Inertia::stop_delay_factor
float stop_delay_factor
Definition RigDef_File.h:306
RigDef::Inertia::stop_function
Ogre::String stop_function
Definition RigDef_File.h:308
RigDef::InterAxle::options
DifferentialTypeVec options
Order matters!
Definition RigDef_File.h:894
RigDef::Lockgroup::nodes
std::vector< Node::Ref > nodes
Definition RigDef_File.h:904
RigDef::ManagedMaterial::TypeToStr
static const char * TypeToStr(ManagedMaterialType type)
Definition RigDef_File.cpp:162
RigDef::NodeDefaults::options
unsigned int options
Bit flags.
Definition RigDef_File.h:950
RigDef::Node::OPTION_c_NO_GROUND_CONTACT
static const BitMask_t OPTION_c_NO_GROUND_CONTACT
Definition RigDef_Node.h:150
RigDef::Node::OPTION_p_NO_PARTICLES
static const BitMask_t OPTION_p_NO_PARTICLES
Definition RigDef_Node.h:154
RigDef::Node::default_minimass
std::shared_ptr< DefaultMinimass > default_minimass
Definition RigDef_Node.h:164
RigDef::Node::_has_load_weight_override
bool _has_load_weight_override
Definition RigDef_Node.h:162
RigDef::Node::OPTION_f_NO_SPARKS
static const BitMask_t OPTION_f_NO_SPARKS
Definition RigDef_Node.h:147
RigDef::Node::OPTION_b_EXTRA_BUOYANCY
static const BitMask_t OPTION_b_EXTRA_BUOYANCY
Definition RigDef_Node.h:153
RigDef::Node::options
BitMask_t options
Definition RigDef_Node.h:160
RigDef::Node::OPTION_L_LOG
static const BitMask_t OPTION_L_LOG
Definition RigDef_Node.h:155
RigDef::Node::OPTION_x_EXHAUST_POINT
static const BitMask_t OPTION_x_EXHAUST_POINT
Definition RigDef_Node.h:148
RigDef::Node::OPTION_e_TERRAIN_EDIT_POINT
static const BitMask_t OPTION_e_TERRAIN_EDIT_POINT
Definition RigDef_Node.h:152
RigDef::Node::node_defaults
std::shared_ptr< NodeDefaults > node_defaults
Definition RigDef_Node.h:163
RigDef::Node::load_weight_override
float load_weight_override
Definition RigDef_Node.h:161
RigDef::Node::OPTION_h_HOOK_POINT
static const BitMask_t OPTION_h_HOOK_POINT
Definition RigDef_Node.h:151
RigDef::Node::position
Ogre::Vector3 position
Definition RigDef_Node.h:159
RigDef::Node::OPTION_m_NO_MOUSE_GRAB
static const BitMask_t OPTION_m_NO_MOUSE_GRAB
Definition RigDef_Node.h:146
RigDef::Node::OPTION_l_LOAD_WEIGHT
static const BitMask_t OPTION_l_LOAD_WEIGHT
Definition RigDef_Node.h:156
RigDef::Node::OPTION_y_EXHAUST_DIRECTION
static const BitMask_t OPTION_y_EXHAUST_DIRECTION
Definition RigDef_Node.h:149
RigDef::Particle::emitter_node
Node::Ref emitter_node
Definition RigDef_File.h:955
RigDef::Particle::reference_node
Node::Ref reference_node
Definition RigDef_File.h:956
RigDef::Particle::particle_system_name
Ogre::String particle_system_name
Definition RigDef_File.h:957
RigDef::Prop::BeaconSpecial::color
Ogre::ColourValue color
Definition RigDef_File.h:996
RigDef::Prop::reference_node
Node::Ref reference_node
Definition RigDef_File.h:999
RigDef::Prop::x_axis_node
Node::Ref x_axis_node
Definition RigDef_File.h:1000
RigDef::Prop::special_prop_dashboard
DashboardSpecial special_prop_dashboard
Definition RigDef_File.h:1009
RigDef::Prop::offset
Ogre::Vector3 offset
Definition RigDef_File.h:1002
RigDef::Prop::mesh_name
Ogre::String mesh_name
Definition RigDef_File.h:1004
RigDef::Prop::special_prop_beacon
BeaconSpecial special_prop_beacon
Definition RigDef_File.h:1008
RigDef::Prop::y_axis_node
Node::Ref y_axis_node
Definition RigDef_File.h:1001
RigDef::Prop::special
SpecialProp special
Definition RigDef_File.h:1007
RigDef::Prop::animations
std::list< Animation > animations
Definition RigDef_File.h:1005
RigDef::Prop::rotation
Ogre::Vector3 rotation
Definition RigDef_File.h:1003
RigDef::RailGroup::node_list
std::vector< Node::Range > node_list
Definition RigDef_File.h:1015
RigDef::RailGroup::id
unsigned int id
Definition RigDef_File.h:1014
RigDef::Rope::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1030
RigDef::Rope::end_node
Node::Ref end_node
Definition RigDef_File.h:1028
RigDef::Rope::root_node
Node::Ref root_node
Definition RigDef_File.h:1027
RigDef::Rotator2::description
Ogre::String description
Definition RigDef_File.h:1052
RigDef::Rotator::spin_left_key
unsigned int spin_left_key
Definition RigDef_File.h:1040
RigDef::Rotator::base_plate_nodes
Node::Ref base_plate_nodes[4]
Definition RigDef_File.h:1037
RigDef::Rotator::axis_nodes
Node::Ref axis_nodes[2]
Definition RigDef_File.h:1036
RigDef::Rotator::rotating_plate_nodes
Node::Ref rotating_plate_nodes[4]
Definition RigDef_File.h:1038
RigDef::Rotator::spin_right_key
unsigned int spin_right_key
Definition RigDef_File.h:1041
RigDef::Shock2::options
BitMask_t options
Definition RigDef_File.h:1112
RigDef::Shock2::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:1100
RigDef::Shock2::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:1095
RigDef::Shock2::short_bound
float short_bound
Maximum contraction limit, in percentage ( 1.00 = 100% )
Definition RigDef_File.h:1109
RigDef::Shock2::progress_factor_damp_out
float progress_factor_damp_out
Progression factor dampout, 0 = disabled, 1...x as multipliers, example:maximum dampingrate == spring...
Definition RigDef_File.h:1108
RigDef::Shock2::damp_out
float damp_out
damping value applied when shock extending
Definition RigDef_File.h:1106
RigDef::Shock2::progress_factor_damp_in
float progress_factor_damp_in
Progression factor for dampin. 0 = disabled, 1...x as multipliers, example:maximum dampingrate == spr...
Definition RigDef_File.h:1104
RigDef::Shock2::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1113
RigDef::Shock2::OPTION_m_METRIC
static const BitMask_t OPTION_m_METRIC
Definition RigDef_File.h:1097
RigDef::Shock2::spring_in
float spring_in
Spring value applied when the shock is compressing.
Definition RigDef_File.h:1101
RigDef::Shock2::OPTION_s_SOFT_BUMP_BOUNDS
static const BitMask_t OPTION_s_SOFT_BUMP_BOUNDS
Definition RigDef_File.h:1096
RigDef::Shock2::precompression
float precompression
Changes compression or extension of the suspension when the truck spawns. This can be used to "level"...
Definition RigDef_File.h:1111
RigDef::Shock2::progress_factor_spring_out
float progress_factor_spring_out
Progression factor springout, 0 = disabled, 1...x as multipliers, example:maximum springrate == sprin...
Definition RigDef_File.h:1107
RigDef::Shock2::OPTION_M_ABSOLUTE_METRIC
static const BitMask_t OPTION_M_ABSOLUTE_METRIC
Definition RigDef_File.h:1098
RigDef::Shock2::spring_out
float spring_out
spring value applied when shock extending
Definition RigDef_File.h:1105
RigDef::Shock2::long_bound
float long_bound
Maximum extension limit, in percentage ( 1.00 = 100% )
Definition RigDef_File.h:1110
RigDef::Shock2::damp_in
float damp_in
Damping value applied when the shock is compressing.
Definition RigDef_File.h:1102
RigDef::Shock2::progress_factor_spring_in
float progress_factor_spring_in
Progression factor for springin. A value of 0 disables this option. 1...x as multipliers,...
Definition RigDef_File.h:1103
RigDef::Shock3::damp_in_slow
float damp_in_slow
Damping value applied when shock is commpressing slower than split in velocity.
Definition RigDef_File.h:1130
RigDef::Shock3::spring_in
float spring_in
Spring value applied when the shock is compressing.
Definition RigDef_File.h:1126
RigDef::Shock3::spring_out
float spring_out
Spring value applied when shock extending.
Definition RigDef_File.h:1128
RigDef::Shock3::OPTION_M_ABSOLUTE_METRIC
static const BitMask_t OPTION_M_ABSOLUTE_METRIC
Definition RigDef_File.h:1123
RigDef::Shock3::damp_in
float damp_in
Damping value applied when the shock is compressing.
Definition RigDef_File.h:1127
RigDef::Shock3::split_vel_in
float split_vel_in
Split velocity in (m/s) - threshold for slow / fast damping during compression.
Definition RigDef_File.h:1131
RigDef::Shock3::options
BitMask_t options
Definition RigDef_File.h:1139
RigDef::Shock3::precompression
float precompression
Changes compression or extension of the suspension when the truck spawns. This can be used to "level"...
Definition RigDef_File.h:1138
RigDef::Shock3::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:1125
RigDef::Shock3::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:1121
RigDef::Shock3::OPTION_m_METRIC
static const BitMask_t OPTION_m_METRIC
Definition RigDef_File.h:1122
RigDef::Shock3::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1140
RigDef::Shock3::damp_out
float damp_out
Damping value applied when shock extending.
Definition RigDef_File.h:1129
RigDef::Shock3::long_bound
float long_bound
Maximum extension limit, in percentage ( 1.00 = 100% )
Definition RigDef_File.h:1137
RigDef::Shock3::short_bound
float short_bound
Maximum contraction limit, in percentage ( 1.00 = 100% )
Definition RigDef_File.h:1136
RigDef::Shock3::damp_out_slow
float damp_out_slow
Damping value applied when shock is commpressing slower than split out velocity.
Definition RigDef_File.h:1133
RigDef::Shock3::damp_out_fast
float damp_out_fast
Damping value applied when shock is commpressing faster than split out velocity.
Definition RigDef_File.h:1135
RigDef::Shock3::damp_in_fast
float damp_in_fast
Damping value applied when shock is commpressing faster than split in velocity.
Definition RigDef_File.h:1132
RigDef::Shock3::split_vel_out
float split_vel_out
Split velocity in (m/s) - threshold for slow / fast damping during extension.
Definition RigDef_File.h:1134
RigDef::Shock::OPTION_L_ACTIVE_LEFT
static const BitMask_t OPTION_L_ACTIVE_LEFT
Definition RigDef_File.h:1076
RigDef::Shock::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1087
RigDef::Shock::damping
float damping
The 'resistance to motion' of the shock. The best value is given by this equation: 2 * sqrt(suspended...
Definition RigDef_File.h:1082
RigDef::Shock::spring_rate
float spring_rate
The 'stiffness' of the shock. The higher the value, the less the shock will move for a given bump.
Definition RigDef_File.h:1081
RigDef::Shock::OPTION_m_METRIC
static const BitMask_t OPTION_m_METRIC
Definition RigDef_File.h:1078
RigDef::Shock::precompression
float precompression
Changes compression or extension of the suspension when the truck spawns. This can be used to "level"...
Definition RigDef_File.h:1085
RigDef::Shock::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:1080
RigDef::Shock::short_bound
float short_bound
Maximum contraction. The shortest length the shock can be, as a proportion of its original length....
Definition RigDef_File.h:1083
RigDef::Shock::long_bound
float long_bound
Maximum extension. The longest length a shock can be, as a proportion of its original length....
Definition RigDef_File.h:1084
RigDef::Shock::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:1075
RigDef::Shock::OPTION_R_ACTIVE_RIGHT
static const BitMask_t OPTION_R_ACTIVE_RIGHT
Definition RigDef_File.h:1077
RigDef::Shock::options
BitMask_t options
Definition RigDef_File.h:1086
RigDef::SlideNode::CONSTRAINT_ATTACH_ALL
static const BitMask_t CONSTRAINT_ATTACH_ALL
Definition RigDef_File.h:1152
RigDef::SlideNode::CONSTRAINT_ATTACH_NONE
static const BitMask_t CONSTRAINT_ATTACH_NONE
Definition RigDef_File.h:1155
RigDef::SlideNode::CONSTRAINT_ATTACH_FOREIGN
static const BitMask_t CONSTRAINT_ATTACH_FOREIGN
Definition RigDef_File.h:1153
RigDef::SlideNode::CONSTRAINT_ATTACH_SELF
static const BitMask_t CONSTRAINT_ATTACH_SELF
Definition RigDef_File.h:1154
RigDef::SlideNode::constraint_flags
BitMask_t constraint_flags
Definition RigDef_File.h:1159
RigDef::SlideNode::rail_node_ranges
std::vector< Node::Range > rail_node_ranges
Definition RigDef_File.h:1158
RigDef::SoundSource2::mode
int mode
A special constant or cinecam index.
Definition RigDef_File.h:1181
RigDef::SoundSource::sound_script_name
Ogre::String sound_script_name
Definition RigDef_File.h:1173
RigDef::Tie::root_node
Node::Ref root_node
Definition RigDef_File.h:1211
RigDef::Tie::auto_shorten_rate
float auto_shorten_rate
Definition RigDef_File.h:1213
RigDef::Tie::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:1208
RigDef::Tie::OPTION_s_DISABLE_SELF_LOCK
static const BitMask_t OPTION_s_DISABLE_SELF_LOCK
Definition RigDef_File.h:1209
RigDef::Tie::options
BitMask_t options
Definition RigDef_File.h:1216
RigDef::Tie::max_reach_length
float max_reach_length
Definition RigDef_File.h:1212
RigDef::TransferCase::gear_ratios
std::vector< float > gear_ratios
Definition RigDef_File.h:1259
RigDef::Trigger::OPTION_B_TRIGGER_BLOCKER
static const BitMask_t OPTION_B_TRIGGER_BLOCKER
Definition RigDef_File.h:1268
RigDef::Trigger::OPTION_s_CMD_NUM_SWITCH
static const BitMask_t OPTION_s_CMD_NUM_SWITCH
Definition RigDef_File.h:1270
RigDef::Trigger::OPTION_h_UNLOCKS_HOOK_GROUP
static const BitMask_t OPTION_h_UNLOCKS_HOOK_GROUP
Definition RigDef_File.h:1271
RigDef::Trigger::OPTION_i_INVISIBLE
static const BitMask_t OPTION_i_INVISIBLE
Definition RigDef_File.h:1264
RigDef::Trigger::OPTION_t_CONTINUOUS
static const BitMask_t OPTION_t_CONTINUOUS
Definition RigDef_File.h:1273
RigDef::Trigger::OPTION_E_ENGINE_TRIGGER
static const BitMask_t OPTION_E_ENGINE_TRIGGER
Definition RigDef_File.h:1274
RigDef::Trigger::OPTION_c_COMMAND_STYLE
static const BitMask_t OPTION_c_COMMAND_STYLE
Definition RigDef_File.h:1265
RigDef::Trigger::OPTION_b_KEY_BLOCKER
static const BitMask_t OPTION_b_KEY_BLOCKER
Definition RigDef_File.h:1267
RigDef::Trigger::contraction_trigger_limit
float contraction_trigger_limit
Definition RigDef_File.h:1277
RigDef::Trigger::OPTION_x_START_DISABLED
static const BitMask_t OPTION_x_START_DISABLED
Definition RigDef_File.h:1266
RigDef::Trigger::options
BitMask_t options
Definition RigDef_File.h:1279
RigDef::Trigger::expansion_trigger_limit
float expansion_trigger_limit
Definition RigDef_File.h:1278
RigDef::Trigger::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:1276
RigDef::Trigger::OPTION_H_LOCKS_HOOK_GROUP
static const BitMask_t OPTION_H_LOCKS_HOOK_GROUP
Definition RigDef_File.h:1272
RigDef::Trigger::OPTION_A_INV_TRIGGER_BLOCKER
static const BitMask_t OPTION_A_INV_TRIGGER_BLOCKER
Definition RigDef_File.h:1269
RigDef::Trigger::shortbound_trigger_action
int shortbound_trigger_action
Definition RigDef_File.h:1283
RigDef::Turboprop2::blade_tip_nodes
Node::Ref blade_tip_nodes[4]
Definition RigDef_File.h:1304
RigDef::Turboprop2::reference_node
Node::Ref reference_node
Definition RigDef_File.h:1302
RigDef::Turboprop2::airfoil
Ogre::String airfoil
Definition RigDef_File.h:1306
RigDef::VideoCamera::camera_role
RoR::VideoCamRole camera_role
Definition RigDef_File.h:1324
RigDef::VideoCamera::material_name
Ogre::String material_name
Definition RigDef_File.h:1326
RigDef::VideoCamera::texture_width
unsigned int texture_width
Definition RigDef_File.h:1320
RigDef::VideoCamera::camera_name
Ogre::String camera_name
Definition RigDef_File.h:1327
RigDef::VideoCamera::alt_orientation_node
Node::Ref alt_orientation_node
Definition RigDef_File.h:1316
RigDef::VideoCamera::alt_reference_node
Node::Ref alt_reference_node
Definition RigDef_File.h:1315
RigDef::VideoCamera::texture_height
unsigned int texture_height
Definition RigDef_File.h:1321
RigDef::VideoCamera::rotation
Ogre::Vector3 rotation
Definition RigDef_File.h:1318
RigDef::VideoCamera::offset
Ogre::Vector3 offset
Definition RigDef_File.h:1317
RigDef::Wing::tex_coords
float tex_coords[8]
Definition RigDef_File.h:1356
RigDef::Wing::min_deflection
float min_deflection
Definition RigDef_File.h:1359
RigDef::Wing::efficacy_coef
float efficacy_coef
Definition RigDef_File.h:1362
RigDef::Wing::control_surface
WingControlSurface control_surface
Definition RigDef_File.h:1357
RigDef::Wing::airfoil
Ogre::String airfoil
Definition RigDef_File.h:1361
RigDef::Wing::max_deflection
float max_deflection
Definition RigDef_File.h:1360
RigDef::Wing::nodes
Node::Ref nodes[8]
Definition RigDef_File.h:1355
Generated on Fri Jan 2 2026 09:37:03 for Rigs of Rods by doxygen 1.9.8