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_Parser.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-2021 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_Parser.h"
27
28#include "Actor.h"
29#include "Application.h"
30#include "DashBoardManager.h"
31#include "SimConstants.h"
32#include "CacheSystem.h"
33#include "Console.h"
34#include "RigDef_File.h"
35#include "RigDef_Regexes.h"
36#include "Utils.h"
37
38#include <OgreException.h>
39#include <OgreString.h>
40#include <OgreStringVector.h>
41#include <OgreStringConverter.h>
42
43#include <algorithm>
44
45using namespace RoR;
46
47namespace RigDef
48{
49
50inline bool IsWhitespace(char c)
51{
52 return (c == ' ') || (c == '\t');
53}
54
55inline bool IsSeparator(char c)
56{
57 return IsWhitespace(c) || (c == ':') || (c == '|') || (c == ',');
58}
59
60inline bool StrEqualsNocase(std::string const & s1, std::string const & s2)
61{
62 if (s1.size() != s2.size()) { return false; }
63 for (size_t i = 0; i < s1.size(); ++i)
64 {
65 if (tolower(s1[i]) != tolower(s2[i])) { return false; }
66 }
67 return true;
68}
69
70Parser::Parser()
71{
72 // Push defaults
73 m_ror_default_inertia = std::shared_ptr<Inertia>(new Inertia);
74 m_ror_node_defaults = std::shared_ptr<NodeDefaults>(new NodeDefaults);
75}
76
77void Parser::ProcessCurrentLine()
78{
79 // First line in file (except blanks or comments) is the actor name
80 if (m_definition->name == "" && m_current_line != "")
81 {
82 m_definition->name = m_current_line; // Already trimmed
83 return;
84 }
85
86 // Split line to tokens
87 if (m_current_block != Keyword::COMMENT &&
88 m_current_block != Keyword::DESCRIPTION)
89 {
90 this->TokenizeCurrentLine();
91 }
92
93 // Detect keyword on current line
94 Keyword keyword = Keyword::INVALID;
95 // Quick check - keyword always starts with ASCII letter
96 char c = tolower(m_current_line[0]); // Note: line comes in trimmed
97 if (c >= 'a' && c <= 'z')
98 {
99 keyword = Parser::IdentifyKeyword(m_current_line);
100 }
101 m_log_keyword = keyword;
102 switch (keyword)
103 {
104 // No keyword - Continue below to process current block.
105 case Keyword::INVALID:
106 break; // << NOT RETURN.
107
108 // Directives without arguments: just record, do not change current block.
109 case Keyword::DISABLEDEFAULTSOUNDS:
110 case Keyword::ENABLE_ADVANCED_DEFORMATION:
111 case Keyword::FORWARDCOMMANDS:
112 case Keyword::HIDEINCHOOSER:
113 case Keyword::IMPORTCOMMANDS:
114 case Keyword::LOCKGROUP_DEFAULT_NOLOCK:
115 case Keyword::RESCUER:
116 case Keyword::ROLLON:
117 case Keyword::SLIDENODE_CONNECT_INSTANTLY:
118 this->ProcessGlobalDirective(keyword);
119 return;
120 case Keyword::END_SECTION:
121 this->ProcessChangeModuleLine(keyword);
122 return;
123
124 // Directives with arguments: process immediately, do not change current block.
125 case Keyword::ADD_ANIMATION:
126 this->ParseDirectiveAddAnimation();
127 return;
128 case Keyword::ANTILOCKBRAKES:
129 this->ParseAntiLockBrakes();
130 return;
131 case Keyword::AUTHOR:
132 this->ParseAuthor();
133 return;
134 case Keyword::BACKMESH:
135 this->ParseDirectiveBackmesh();
136 return;
137 case Keyword::CRUISECONTROL:
138 this->ParseCruiseControl();
139 return;
140 case Keyword::DEFAULT_SKIN:
141 this->ParseDirectiveDefaultSkin();
142 return;
143 case Keyword::DETACHER_GROUP:
144 this->ParseDirectiveDetacherGroup();
145 return;
146 case Keyword::EXTCAMERA:
147 this->ParseExtCamera();
148 return;
149 case Keyword::FILEFORMATVERSION:
150 this->ParseFileFormatVersion();
151 return;
152 case Keyword::FILEINFO:
153 this->ParseFileinfo();
154 return;
155 case Keyword::FLEXBODY_CAMERA_MODE:
156 this->ParseDirectiveFlexbodyCameraMode();
157 return;
158 case Keyword::FORSET:
159 this->ParseDirectiveForset();
160 return;
161 case Keyword::FORVERT:
162 this->ParseDirectiveForvert();
163 return;
164 case Keyword::GUID:
165 this->ParseGuid();
166 return;
167 case Keyword::PROP_CAMERA_MODE:
168 this->ParseDirectivePropCameraMode();
169 return;
170 case Keyword::SECTION:
171 this->ParseDirectiveSection();
172 return;
173 case Keyword::SET_BEAM_DEFAULTS:
174 this->ParseDirectiveSetBeamDefaults();
175 return;
176 case Keyword::SET_BEAM_DEFAULTS_SCALE:
177 this->ParseDirectiveSetBeamDefaultsScale();
178 return;
179 case Keyword::SET_COLLISION_RANGE:
180 this->ParseSetCollisionRange();
181 return;
182 case Keyword::SET_DEFAULT_MINIMASS:
183 this->ParseDirectiveSetDefaultMinimass();
184 return;
185 case Keyword::SET_INERTIA_DEFAULTS:
186 this->ParseDirectiveSetInertiaDefaults();
187 return;
188 case Keyword::SET_MANAGEDMATERIALS_OPTIONS:
189 this->ParseDirectiveSetManagedMaterialsOptions();
190 return;
191 case Keyword::SET_NODE_DEFAULTS:
192 this->ParseDirectiveSetNodeDefaults();
193 return;
194 case Keyword::SET_SKELETON_SETTINGS:
195 this->ParseSetSkeletonSettings();
196 return;
197 case Keyword::SPEEDLIMITER:
198 this->ParseSpeedLimiter();
199 return;
200 case Keyword::SUBMESH:
201 this->ParseDirectiveSubmesh();
202 return;
203 case Keyword::SUBMESH_GROUNDMODEL:
204 this->ParseSubmeshGroundModel();
205 return;
206 case Keyword::TRACTIONCONTROL:
207 this->ParseTractionControl();
208 return;
209
210 // Keywords which end current block:
211 case Keyword::END_COMMENT:
212 case Keyword::END_DESCRIPTION:
213 case Keyword::END:
214 this->BeginBlock(Keyword::INVALID);
215 return;
216
217 // Ignored keywords (obsolete):
218 case Keyword::ENVMAP:
219 case Keyword::HOOKGROUP:
220 case Keyword::NODECOLLISION:
221 case Keyword::RIGIDIFIERS:
222 return;
223
224 // Keywords which start new block:
225 default:
226 this->BeginBlock(keyword);
227 return;
228 }
229
230 // Block extent tracking - assumes single 'nodes[2]' and 'beams' block in file.
231 if ((keyword == Keyword::NODES || keyword == Keyword::NODES2) && m_current_module->_hint_nodes12_start_linenumber == -1)
232 {
233 m_current_module->_hint_nodes12_start_linenumber = (int)m_current_line_number;
234 }
235 else if (keyword == Keyword::BEAMS && m_current_module->_hint_beams_start_linenumber == -1)
236 {
237 m_current_module->_hint_beams_start_linenumber = (int)m_current_line_number;
238 }
239 else if (m_current_module->_hint_nodes12_end_linenumber == -1)
240 {
241 m_current_module->_hint_nodes12_start_linenumber = (int)m_current_line_number - 1;
242 }
243 else if (m_current_module->_hint_beams_end_linenumber == -1)
244 {
245 m_current_module->_hint_beams_start_linenumber = (int)m_current_line_number - 1;
246 }
247
248 // Parse current block, if any
249 m_log_keyword = m_current_block;
250 switch (m_current_block)
251 {
252 case Keyword::AIRBRAKES: this->ParseAirbrakes(); return;
253 case Keyword::ANIMATORS: this->ParseAnimator(); return;
254 case Keyword::ASSETPACKS: this->ParseAssetpacks(); return;
255 case Keyword::AXLES: this->ParseAxles(); return;
256 case Keyword::BEAMS: this->ParseBeams(); return;
257 case Keyword::BRAKES: this->ParseBrakes(); return;
258 case Keyword::CAMERAS: this->ParseCameras(); return;
259 case Keyword::CAB: this->ParseCab(); return;
260 case Keyword::CAMERARAIL: this->ParseCameraRails(); return;
261 case Keyword::CINECAM: this->ParseCinecam(); return;
262 case Keyword::COMMANDS:
263 case Keyword::COMMANDS2: this->ParseCommandsUnified(); return;
264 case Keyword::COLLISIONBOXES: this->ParseCollisionBox(); return;
265 case Keyword::CONTACTERS: this->ParseContacter(); return;
266 case Keyword::CUSTOMDASHBOARDINPUTS:this->ParseCustomDashboardInputs(); return;
267 case Keyword::DESCRIPTION: this->ParseDescription(); return;
268 case Keyword::ENGINE: this->ParseEngine(); return;
269 case Keyword::ENGOPTION: this->ParseEngoption(); return;
270 case Keyword::ENGTURBO: this->ParseEngturbo(); return;
271 case Keyword::EXHAUSTS: this->ParseExhaust(); return;
272 case Keyword::FIXES: this->ParseFixes(); return;
273 case Keyword::FLARES:
274 case Keyword::FLARES2: this->ParseFlaresUnified(); return;
275 case Keyword::FLARES3: this->ParseFlares3(); return;
276 case Keyword::FLAREGROUPS_NO_IMPORT:this->ParseFlaregroupsNoImport(); return;
277 case Keyword::FLEXBODIES: this->ParseFlexbody(); return;
278 case Keyword::FLEXBODYWHEELS: this->ParseFlexBodyWheel(); return;
279 case Keyword::FUSEDRAG: this->ParseFusedrag(); return;
280 case Keyword::GLOBALS: this->ParseGlobals(); return;
281 case Keyword::GUISETTINGS: this->ParseGuiSettings(); return;
282 case Keyword::HELP: this->ParseHelp(); return;
283 case Keyword::HOOKS: this->ParseHook(); return;
284 case Keyword::HYDROS: this->ParseHydros(); return;
285 case Keyword::INTERAXLES: this->ParseInterAxles(); return;
286 case Keyword::LOCKGROUPS: this->ParseLockgroups(); return;
287 case Keyword::MANAGEDMATERIALS: this->ParseManagedMaterials(); return;
288 case Keyword::MATERIALFLAREBINDINGS:this->ParseMaterialFlareBindings(); return;
289 case Keyword::MESHWHEELS: this->ParseMeshWheel(); return;
290 case Keyword::MESHWHEELS2: this->ParseMeshWheel2(); return;
291 case Keyword::MINIMASS: this->ParseMinimass(); return;
292 case Keyword::NODES:
293 case Keyword::NODES2: this->ParseNodesUnified(); return;
294 case Keyword::PARTICLES: this->ParseParticles(); return;
295 case Keyword::PISTONPROPS: this->ParsePistonprops(); return;
296 case Keyword::PROPS: this->ParseProps(); return;
297 case Keyword::RAILGROUPS: this->ParseRailGroups(); return;
298 case Keyword::ROPABLES: this->ParseRopables(); return;
299 case Keyword::ROPES: this->ParseRopes(); return;
300 case Keyword::ROTATORS:
301 case Keyword::ROTATORS2: this->ParseRotatorsUnified(); return;
302 case Keyword::SCREWPROPS: this->ParseScrewprops(); return;
303 case Keyword::SCRIPTS: this->ParseScripts(); return;
304 case Keyword::SHOCKS: this->ParseShock(); return;
305 case Keyword::SHOCKS2: this->ParseShock2(); return;
306 case Keyword::SHOCKS3: this->ParseShock3(); return;
307 case Keyword::SLIDENODES: this->ParseSlidenodes(); return;
308 case Keyword::SOUNDSOURCES: this->ParseSoundsources(); return;
309 case Keyword::SOUNDSOURCES2: this->ParseSoundsources2(); return;
310 case Keyword::TEXCOORDS: this->ParseTexcoords(); return;
311 case Keyword::TIES: this->ParseTies(); return;
312 case Keyword::TORQUECURVE: this->ParseTorqueCurve(); return;
313 case Keyword::TRANSFERCASE: this->ParseTransferCase(); return;
314 case Keyword::TRIGGERS: this->ParseTriggers(); return;
315 case Keyword::TURBOJETS: this->ParseTurbojets(); return;
316 case Keyword::TURBOPROPS:
317 case Keyword::TURBOPROPS2: this->ParseTurbopropsUnified(); return;
318 case Keyword::VIDEOCAMERA: this->ParseVideoCamera(); return;
319 case Keyword::WHEELDETACHERS: this->ParseWheelDetachers(); return;
320 case Keyword::WHEELS: this->ParseWheel(); return;
321 case Keyword::WHEELS2: this->ParseWheel2(); return;
322 case Keyword::WINGS: this->ParseWing(); return;
323 default:;
324 };
325}
326
327bool Parser::CheckNumArguments(int min_args)
328{
329 if (min_args > m_num_args)
330 {
331 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
332 fmt::format("Not enough arguments (got {}, {} needed), skipping line", m_num_args, min_args));
333 return false;
334 }
335 return true;
336}
337
338// --------------------------------------------------------------------------
339// Parsing individual keywords
340// --------------------------------------------------------------------------
341
342void Parser::ParseWing()
343{
344 if (!this->CheckNumArguments(16)) { return; }
345
346 Wing wing;
347
348 for (int i = 0; i < 8; i++) { wing.nodes[i] = this->GetArgNodeRef (i); }
349 for (int i = 8; i < 16; i++) { wing.tex_coords[i-8] = this->GetArgFloat (i); }
350
351 if (m_num_args > 16) { wing.control_surface = this->GetArgWingSurface (16); }
352 if (m_num_args > 17) { wing.chord_point = this->GetArgFloat (17); }
353 if (m_num_args > 18) { wing.min_deflection = this->GetArgFloat (18); }
354 if (m_num_args > 19) { wing.max_deflection = this->GetArgFloat (19); }
355 if (m_num_args > 20) { wing.airfoil = this->GetArgStr (20); }
356 if (m_num_args > 21) { wing.efficacy_coef = this->GetArgFloat (21); }
357
358 m_current_module->wings.push_back(wing);
359 this->FlushPendingDocComment(m_current_module->wings.size(), RigDef::Keyword::WINGS);
360}
361
362void Parser::ParseSetCollisionRange()
363{
364 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
365
366 CollisionRange cr;
367 cr.node_collision_range = this->GetArgFloat(1);
368
369 m_current_module->set_collision_range.push_back(cr);
370 this->FlushPendingDocComment(m_current_module->set_collision_range.size(), RigDef::Keyword::SET_COLLISION_RANGE);
371}
372
373void Parser::ParseWheel2()
374{
375 if (!this->CheckNumArguments(17)) { return; }
376
377 Wheel2 wheel_2;
378 wheel_2.node_defaults = m_user_node_defaults;
379 wheel_2.beam_defaults = m_user_beam_defaults;
380
381 wheel_2.rim_radius = this->GetArgFloat ( 0);
382 wheel_2.tyre_radius = this->GetArgFloat ( 1);
383 wheel_2.width = this->GetArgFloat ( 2);
384 wheel_2.num_rays = this->GetArgInt ( 3);
385 wheel_2.nodes[0] = this->GetArgNodeRef ( 4);
386 wheel_2.nodes[1] = this->GetArgNodeRef ( 5);
387 wheel_2.rigidity_node = this->GetArgRigidityNode ( 6);
388 wheel_2.braking = this->GetArgBraking ( 7);
389 wheel_2.propulsion = this->GetArgPropulsion ( 8);
390 wheel_2.reference_arm_node = this->GetArgNodeRef ( 9);
391 wheel_2.mass = this->GetArgFloat (10);
392 wheel_2.rim_springiness = this->GetArgFloat (11);
393 wheel_2.rim_damping = this->GetArgFloat (12);
394 wheel_2.tyre_springiness = this->GetArgFloat (13);
395 wheel_2.tyre_damping = this->GetArgFloat (14);
396 wheel_2.face_material_name = this->GetArgStr (15);
397 wheel_2.band_material_name = this->GetArgStr (16);
398
399 if (m_sequential_importer.IsEnabled())
400 {
401 m_sequential_importer.GenerateNodesForWheel(Keyword::WHEELS2, wheel_2.num_rays, wheel_2.rigidity_node.IsValidAnyState());
402 }
403
404 m_current_module->wheels2.push_back(wheel_2);
405 this->FlushPendingDocComment(m_current_module->wheels2.size(), RigDef::Keyword::WHEELS2);
406}
407
408void Parser::ParseWheel()
409{
410 if (! this->CheckNumArguments(14)) { return; }
411
412 Wheel wheel;
413 wheel.node_defaults = m_user_node_defaults;
414 wheel.beam_defaults = m_user_beam_defaults;
415
416 wheel.radius = this->GetArgFloat ( 0);
417 wheel.width = this->GetArgFloat ( 1);
418 wheel.num_rays = this->GetArgInt ( 2);
419 wheel.nodes[0] = this->GetArgNodeRef ( 3);
420 wheel.nodes[1] = this->GetArgNodeRef ( 4);
421 wheel.rigidity_node = this->GetArgRigidityNode ( 5);
422 wheel.braking = this->GetArgBraking ( 6);
423 wheel.propulsion = this->GetArgPropulsion ( 7);
424 wheel.reference_arm_node = this->GetArgNodeRef ( 8);
425 wheel.mass = this->GetArgFloat ( 9);
426 wheel.springiness = this->GetArgFloat (10);
427 wheel.damping = this->GetArgFloat (11);
428 wheel.face_material_name = this->GetArgStr (12);
429 wheel.band_material_name = this->GetArgStr (13);
430
431 if (m_sequential_importer.IsEnabled())
432 {
433 m_sequential_importer.GenerateNodesForWheel(Keyword::WHEELS, wheel.num_rays, wheel.rigidity_node.IsValidAnyState());
434 }
435
436 m_current_module->wheels.push_back(wheel);
437 this->FlushPendingDocComment(m_current_module->wheels.size(), RigDef::Keyword::WHEELS);
438}
439
440void Parser::ParseWheelDetachers()
441{
442 if (! this->CheckNumArguments(2)) { return; }
443
444 WheelDetacher wheeldetacher;
445
446 wheeldetacher.wheel_id = this->GetArgInt(0);
447 wheeldetacher.detacher_group = this->GetArgInt(1);
448
449 m_current_module->wheeldetachers.push_back(wheeldetacher);
450 this->FlushPendingDocComment(m_current_module->wheeldetachers.size(), RigDef::Keyword::WHEELDETACHERS);
451}
452
453void Parser::ParseTractionControl()
454{
455 Ogre::StringVector tokens = Ogre::StringUtil::split(m_current_line + 15, ","); // "TractionControl" = 15 characters
456 m_num_args = (int)tokens.size();
457 if (! this->CheckNumArguments(2)) { return; }
458
459 TractionControl tc;
460 tc.regulation_force = this->ParseArgFloat(tokens[0].c_str());
461 tc.wheel_slip = this->ParseArgFloat(tokens[1].c_str());
462 if (tokens.size() > 2) { tc.fade_speed = this->ParseArgFloat(tokens[2].c_str()); }
463 if (tokens.size() > 3) { tc.pulse_per_sec = this->ParseArgFloat(tokens[3].c_str()); }
464
465 for (unsigned int i=4; i<tokens.size(); i++)
466 {
467 Ogre::StringVector args2 = Ogre::StringUtil::split(tokens[i], ":");
468 Ogre::StringUtil::trim(args2[0]);
469 Ogre::StringUtil::toLowerCase(args2[0]);
470
471 if (args2[0] == "mode" && args2.size() == 2)
472 {
473 Ogre::StringVector attrs = Ogre::StringUtil::split(args2[1], "&");
474 auto itor = attrs.begin();
475 auto endi = attrs.end();
476 for (; itor != endi; ++itor)
477 {
478 std::string attr = *itor;
479 Ogre::StringUtil::trim(attr);
480 Ogre::StringUtil::toLowerCase(attr);
481 if (strncmp(attr.c_str(), "nodash", 6) == 0) { tc.attr_no_dashboard = true; }
482 else if (strncmp(attr.c_str(), "notoggle", 8) == 0) { tc.attr_no_toggle = true; }
483 else if (strncmp(attr.c_str(), "on", 2) == 0) { tc.attr_is_on = true; }
484 else if (strncmp(attr.c_str(), "off", 3) == 0) { tc.attr_is_on = false; }
485 }
486 }
487 else
488 {
489 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "missing mode");
490 tc.attr_no_dashboard = false;
491 tc.attr_no_toggle = false;
492 tc.attr_is_on = true;
493 }
494 }
495
496 m_current_module->tractioncontrol.push_back(tc);
497 this->FlushPendingDocComment(m_current_module->tractioncontrol.size(), RigDef::Keyword::TRACTIONCONTROL);
498}
499
500void Parser::ParseTransferCase()
501{
502 if (! this->CheckNumArguments(2)) { return; }
503
504 TransferCase tc;
505
506 tc.a1 = this->GetArgInt(0) - 1;
507 tc.a2 = this->GetArgInt(1) - 1;
508 if (m_num_args > 2) { tc.has_2wd = this->GetArgInt(2); }
509 if (m_num_args > 3) { tc.has_2wd_lo = this->GetArgInt(3); }
510 for (int i = 4; i < m_num_args; i++) { tc.gear_ratios.push_back(this->GetArgFloat(i)); }
511
512 m_current_module->transfercase.push_back(tc);
513 this->FlushPendingDocComment(m_current_module->transfercase.size(), RigDef::Keyword::TRANSFERCASE);
514}
515
516void Parser::ParseSubmeshGroundModel()
517{
518 if (!this->CheckNumArguments(2)) { return; } // Items: keyword, arg
519
520 m_current_module->submesh_groundmodel.push_back(this->GetArgStr(1));
521 this->FlushPendingDocComment(m_current_module->submesh_groundmodel.size(), RigDef::Keyword::SUBMESH_GROUNDMODEL);
522}
523
524void Parser::ParseSpeedLimiter()
525{
526 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
527
528 SpeedLimiter sl;
529 sl.is_enabled = true;
530 sl.max_speed = this->GetArgFloat(1);
531
532 m_current_module->speedlimiter.push_back(sl);
533 this->FlushPendingDocComment(m_current_module->speedlimiter.size(), RigDef::Keyword::SPEEDLIMITER);
534}
535
536void Parser::ParseSetSkeletonSettings()
537{
538 if (! this->CheckNumArguments(2)) { return; }
539
540 if (m_current_module->set_skeleton_settings.size() == 0)
541 {
542 m_current_module->set_skeleton_settings.push_back(SkeletonSettings());
543 }
544
545 SkeletonSettings& skel = m_current_module->set_skeleton_settings[0];
546 skel.visibility_range_meters = this->GetArgFloat(1);
547 if (m_num_args > 2) { skel.beam_thickness_meters = this->GetArgFloat(2); }
548
549 // Defaults
550 if (skel.visibility_range_meters < 0.f) { skel.visibility_range_meters = 150.f; }
551 if (skel.beam_thickness_meters < 0.f) { skel.beam_thickness_meters = BEAM_SKELETON_DIAMETER; }
552}
553
554void Parser::ParseDirectiveSetNodeDefaults()
555{
556 if (!this->CheckNumArguments(2)) { return; }
557
558 float load_weight = this->GetArgFloat(1);
559 float friction = (m_num_args > 2) ? this->GetArgFloat(2) : -1;
560 float volume = (m_num_args > 3) ? this->GetArgFloat(3) : -1;
561 float surface = (m_num_args > 4) ? this->GetArgFloat(4) : -1;
562
563 m_user_node_defaults = std::shared_ptr<NodeDefaults>( new NodeDefaults(*m_user_node_defaults) );
564
565 m_user_node_defaults->load_weight = (load_weight < 0) ? m_ror_node_defaults->load_weight : load_weight;
566 m_user_node_defaults->friction = (friction < 0) ? m_ror_node_defaults->friction : friction;
567 m_user_node_defaults->volume = (volume < 0) ? m_ror_node_defaults->volume : volume;
568 m_user_node_defaults->surface = (surface < 0) ? m_ror_node_defaults->surface : surface;
569
570 if (m_num_args > 5) m_user_node_defaults->options = this->GetArgNodeOptions(5);
571}
572
573void Parser::ParseDirectiveSetManagedMaterialsOptions()
574{
575 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
576
577 // Legacy behavior.
578 m_current_managed_material_options.double_sided = (this->GetArgChar(1) != '0');
579}
580
581void Parser::ParseDirectiveSetBeamDefaultsScale()
582{
583 if (! this->CheckNumArguments(5)) { return; }
584
585 BeamDefaults* b = new BeamDefaults(*m_user_beam_defaults);
586 b->scale.springiness = this->GetArgFloat(1);
587
588 if (m_num_args > 2) { b->scale.damping_constant = this->GetArgFloat(2); }
589 if (m_num_args > 3) { b->scale.deformation_threshold_constant = this->GetArgFloat(3); }
590 if (m_num_args > 4) { b->scale.breaking_threshold_constant = this->GetArgFloat(4); }
591
592 m_user_beam_defaults = std::shared_ptr<BeamDefaults>(b);
593}
594
595void Parser::ParseDirectiveSetBeamDefaults()
596{
597 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
598
599 BeamDefaults d(*m_user_beam_defaults);
600
601 // What's the state of "enable_advanced_deformation" feature at this point?
602 // Directive "enable_advanced_deformation" alters the effects of BeamDefaults
603 // Since the old parser worked on-the-fly, only BeamDefaults defined after the directive were affected
604
605 d._enable_advanced_deformation = m_definition->enable_advanced_deformation;
606
607 d._is_user_defined = true; //The "_enable_advanced_deformation" must only be aplied to user-defined values, not defaults.
608 d.springiness = this->GetArgFloat(1);
609
610 if (m_num_args > 2) { d.damping_constant = this->GetArgFloat(2); }
611 if (m_num_args > 3) { d.deformation_threshold = this->GetArgFloat(3); }
612 if (m_num_args > 4) { d.breaking_threshold = this->GetArgFloat(4); }
613 if (m_num_args > 5) { d.visual_beam_diameter = this->GetArgFloat(5); }
614 if (m_num_args > 6) { d.beam_material_name = this->GetArgStr (6); }
615 if (m_num_args > 7) { d.plastic_deform_coef = this->GetArgFloat(7); }
616
617 if (m_num_args > 7 && d.plastic_deform_coef >= 0.0f) { d._is_plastic_deform_coef_user_defined = true; }
618
619 if (d.springiness < 0.f) { d.springiness = DEFAULT_SPRING; }
620 if (d.damping_constant < 0.f) { d.damping_constant = DEFAULT_DAMP; }
621 if (d.deformation_threshold < 0.f) { d.deformation_threshold = BEAM_DEFORM; }
622 if (d.breaking_threshold < 0.f) { d.breaking_threshold = BEAM_BREAK; }
623 if (d.visual_beam_diameter < 0.f) { d.visual_beam_diameter = DEFAULT_BEAM_DIAMETER; }
624 if (d.plastic_deform_coef < 0.f) { d.plastic_deform_coef = BEAM_PLASTIC_COEF_DEFAULT; }
625
626 m_user_beam_defaults = std::shared_ptr<BeamDefaults>( new BeamDefaults(d) );
627 return;
628}
629
630void Parser::ParseDirectivePropCameraMode()
631{
632 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
633
634 if (m_current_module->props.size() > 0)
635 {
636 m_current_module->props[m_current_module->props.size() - 1].camera_settings.mode = this->GetArgInt(1);
637 }
638 else
639 {
640 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "This line must come after a prop!");
641 }
642}
643
644void Parser::ParseDirectiveSubmesh()
645{
646 this->BeginBlock(Keyword::INVALID); // flush the current submesh
647 m_current_submesh = std::shared_ptr<Submesh>( new Submesh() );
648}
649
650void Parser::ParseDirectiveBackmesh()
651{
652 if (m_current_submesh)
653 {
654 m_current_submesh->backmesh = true;
655 }
656 else
657 {
658 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "must come after 'submesh'");
659 }
660}
661
662void Parser::ProcessGlobalDirective(Keyword keyword) // Directives that should only appear in root module
663{
664 switch (keyword)
665 {
666 case Keyword::DISABLEDEFAULTSOUNDS: m_definition->disable_default_sounds = true; return;
667 case Keyword::ENABLE_ADVANCED_DEFORMATION: m_definition->enable_advanced_deformation = true; return;
668 case Keyword::FORWARDCOMMANDS: m_definition->forward_commands = true; return;
669 case Keyword::IMPORTCOMMANDS: m_definition->import_commands = true; return;
670 case Keyword::HIDEINCHOOSER: m_definition->hide_in_chooser = true; return;
671 case Keyword::LOCKGROUP_DEFAULT_NOLOCK: m_definition->lockgroup_default_nolock = true; return;
672 case Keyword::RESCUER: m_definition->rescuer = true; return;
673 case Keyword::ROLLON: m_definition->rollon = true; return;
674 case Keyword::SLIDENODE_CONNECT_INSTANTLY: m_definition->slide_nodes_connect_instantly = true; return;
675
676 default: return;
677 }
678}
679
680void Parser::_ParseBaseMeshWheel(BaseMeshWheel& mesh_wheel)
681{
682 mesh_wheel.node_defaults = m_user_node_defaults;
683 mesh_wheel.beam_defaults = m_user_beam_defaults;
684
685 mesh_wheel.tyre_radius = this->GetArgFloat ( 0);
686 mesh_wheel.rim_radius = this->GetArgFloat ( 1);
687 mesh_wheel.width = this->GetArgFloat ( 2);
688 mesh_wheel.num_rays = this->GetArgInt ( 3);
689 mesh_wheel.nodes[0] = this->GetArgNodeRef ( 4);
690 mesh_wheel.nodes[1] = this->GetArgNodeRef ( 5);
691 mesh_wheel.rigidity_node = this->GetArgRigidityNode ( 6);
692 mesh_wheel.braking = this->GetArgBraking ( 7);
693 mesh_wheel.propulsion = this->GetArgPropulsion ( 8);
694 mesh_wheel.reference_arm_node = this->GetArgNodeRef ( 9);
695 mesh_wheel.mass = this->GetArgFloat (10);
696 mesh_wheel.spring = this->GetArgFloat (11);
697 mesh_wheel.damping = this->GetArgFloat (12);
698 mesh_wheel.side = this->GetArgWheelSide (13);
699 mesh_wheel.mesh_name = this->GetArgStr (14);
700 mesh_wheel.material_name = this->GetArgStr (15);
701}
702
703void Parser::ParseMeshWheel()
704{
705 if (! this->CheckNumArguments(16)) { return; }
706
707 MeshWheel mesh_wheel;
708 this->_ParseBaseMeshWheel(mesh_wheel);
709
710 if (m_sequential_importer.IsEnabled())
711 {
712 m_sequential_importer.GenerateNodesForWheel(Keyword::MESHWHEELS, mesh_wheel.num_rays, mesh_wheel.rigidity_node.IsValidAnyState());
713 }
714
715 m_current_module->meshwheels.push_back(mesh_wheel);
716 this->FlushPendingDocComment(m_current_module->meshwheels.size(), RigDef::Keyword::MESHWHEELS);
717}
718
719void Parser::ParseMeshWheel2()
720{
721 if (! this->CheckNumArguments(16)) { return; }
722
723 MeshWheel2 mesh_wheel;
724 this->_ParseBaseMeshWheel(mesh_wheel);
725
726 if (m_sequential_importer.IsEnabled())
727 {
728 m_sequential_importer.GenerateNodesForWheel(Keyword::MESHWHEELS2, mesh_wheel.num_rays, mesh_wheel.rigidity_node.IsValidAnyState());
729 }
730
731 m_current_module->meshwheels2.push_back(mesh_wheel);
732 this->FlushPendingDocComment(m_current_module->meshwheels2.size(), RigDef::Keyword::MESHWHEELS2);
733}
734
735void Parser::ParseHook()
736{
737 if (! this->CheckNumArguments(1)) { return; }
738
739 Hook hook;
740 hook.node = this->GetArgNodeRef(0);
741
742 int i = 1;
743 while (i < m_num_args)
744 {
745 std::string attr = this->GetArgStr(i);
746 Ogre::StringUtil::trim(attr);
747 const bool has_value = (i < (m_num_args - 1));
748
749 // Values
750 if (has_value && (attr == "hookrange") ) { hook.option_hook_range = this->GetArgFloat(++i); }
751 else if (has_value && (attr == "speedcoef") ) { hook.option_speed_coef = this->GetArgFloat(++i); }
752 else if (has_value && (attr == "maxforce") ) { hook.option_max_force = this->GetArgFloat(++i); }
753 else if (has_value && (attr == "timer") ) { hook.option_timer = this->GetArgFloat(++i); }
754 else if (has_value && (attr == "hookgroup" || attr == "hgroup") ) { hook.option_hookgroup = this->GetArgInt (++i); }
755 else if (has_value && (attr == "lockgroup" || attr == "lgroup") ) { hook.option_lockgroup = this->GetArgInt (++i); }
756 else if (has_value && (attr == "shortlimit" || attr == "short_limit")) { hook.option_min_range_meters = this->GetArgFloat(++i); }
757 // Flags
758 else if ((attr == "selflock") ||(attr == "self-lock") ||(attr == "self_lock") ) { hook.flag_self_lock = true; }
759 else if ((attr == "autolock") ||(attr == "auto-lock") ||(attr == "auto_lock") ) { hook.flag_auto_lock = true; }
760 else if ((attr == "nodisable")||(attr == "no-disable")||(attr == "no_disable")) { hook.flag_no_disable = true; }
761 else if ((attr == "norope") ||(attr == "no-rope") ||(attr == "no_rope") ) { hook.flag_no_rope = true; }
762 else if ((attr == "visible") ||(attr == "vis") ) { hook.flag_visible = true; }
763 else
764 {
765 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, fmt::format("ignoring invalid option '{}'", attr));
766 }
767 i++;
768 }
769
770 m_current_module->hooks.push_back(hook);
771 this->FlushPendingDocComment(m_current_module->hooks.size(), RigDef::Keyword::HOOKS);
772}
773
774void Parser::ParseHelp()
775{
776 Help h;
777 h.material = m_current_line; // already trimmed
778 m_current_module->help.push_back(h);
779}
780
781void Parser::ParseGuiSettings()
782{
783 if (! this->CheckNumArguments(2)) { return; }
784
785 GuiSettings gs;
786 gs.key = this->GetArgStr(0);
787 gs.value = this->GetArgStr(1);
788
789 m_current_module->guisettings.push_back(gs);
790 this->FlushPendingDocComment(m_current_module->guisettings.size(), RigDef::Keyword::GUISETTINGS);
791}
792
793void Parser::ParseGuid()
794{
795 if (! this->CheckNumArguments(2)) { return; }
796
797 Guid g;
798 g.guid = this->GetArgStr(1);
799
800 m_current_module->guid.push_back(g);
801 this->FlushPendingDocComment(m_current_module->guid.size(), RigDef::Keyword::GUID);
802}
803
804void Parser::ParseGlobals()
805{
806 if (! this->CheckNumArguments(2)) { return; }
807
808 Globals globals;
809 globals.dry_mass = this->GetArgFloat(0);
810 globals.cargo_mass = this->GetArgFloat(1);
811
812 if (m_num_args > 2) { globals.material_name = this->GetArgStr(2); }
813
814 m_current_module->globals.push_back(globals);
815 this->FlushPendingDocComment(m_current_module->globals.size(), RigDef::Keyword::GLOBALS);
816}
817
818void Parser::ParseFusedrag()
819{
820 if (! this->CheckNumArguments(3)) { return; }
821
822 Fusedrag fusedrag;
823 fusedrag.front_node = this->GetArgNodeRef(0);
824 fusedrag.rear_node = this->GetArgNodeRef(1);
825
826 if (this->GetArgStr(2) == "autocalc")
827 {
828 fusedrag.autocalc = true;
829
830 // Fusedrag autocalculation from truck size
831 if (m_num_args > 3) { fusedrag.area_coefficient = this->GetArgFloat(3); }
832 if (m_num_args > 4) { fusedrag.airfoil_name = this->GetArgStr (4); }
833 }
834 else
835 {
836 // Original calculation
837 fusedrag.approximate_width = this->GetArgFloat(2);
838
839 if (m_num_args > 3) { fusedrag.airfoil_name = this->GetArgStr(3); }
840 }
841
842 m_current_module->fusedrag.push_back(fusedrag);
843 this->FlushPendingDocComment(m_current_module->fusedrag.size(), RigDef::Keyword::FUSEDRAG);
844}
845
846void Parser::ParseDirectiveFlexbodyCameraMode()
847{
848 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, arg
849
850 if (m_current_module->flexbodies.size() > 0)
851 {
852 m_current_module->flexbodies[m_current_module->flexbodies.size() - 1].camera_settings.mode = this->GetArgInt(1);
853 }
854 else
855 {
856 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "This line must come after a flexbody!");
857 }
858}
859
860void Parser::ParseCab()
861{
862 if (! this->CheckNumArguments(3)) { return; }
863
864 if (!m_current_submesh)
865 {
866 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "must come after 'submesh'");
867 return;
868 }
869
870 Cab cab;
871 cab.nodes[0] = this->GetArgNodeRef(0);
872 cab.nodes[1] = this->GetArgNodeRef(1);
873 cab.nodes[2] = this->GetArgNodeRef(2);
874 if (m_num_args > 3) cab.options = this->GetArgCabOptions(3);
875
876 m_current_submesh->cab_triangles.push_back(cab);
877 this->FlushPendingDocComment(m_current_submesh->cab_triangles.size(), RigDef::Keyword::CAB);
878}
879
880void Parser::ParseTexcoords()
881{
882 if (! this->CheckNumArguments(3)) { return; }
883
884 if (!m_current_submesh)
885 {
886 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "must come after 'submesh'");
887 return;
888 }
889
890 Texcoord texcoord;
891 texcoord.node = this->GetArgNodeRef(0);
892 texcoord.u = this->GetArgFloat (1);
893 texcoord.v = this->GetArgFloat (2);
894
895 m_current_submesh->texcoords.push_back(texcoord);
896 this->FlushPendingDocComment(m_current_submesh->texcoords.size(), RigDef::Keyword::TEXCOORDS);
897}
898
899void Parser::ParseFlexbody()
900{
901 if (! this->CheckNumArguments(10)) { return; }
902
903 Flexbody flexbody;
904 flexbody.reference_node = this->GetArgNodeRef (0);
905 flexbody.x_axis_node = this->GetArgNodeRef (1);
906 flexbody.y_axis_node = this->GetArgNodeRef (2);
907 flexbody.offset.x = this->GetArgFloat (3);
908 flexbody.offset.y = this->GetArgFloat (4);
909 flexbody.offset.z = this->GetArgFloat (5);
910 flexbody.rotation.x = this->GetArgFloat (6);
911 flexbody.rotation.y = this->GetArgFloat (7);
912 flexbody.rotation.z = this->GetArgFloat (8);
913 flexbody.mesh_name = this->GetArgStr (9);
914
915 m_current_module->flexbodies.push_back(flexbody);
916 this->FlushPendingDocComment(m_current_module->flexbodies.size(), RigDef::Keyword::FLEXBODIES);
917}
918
919void Parser::ParseDirectiveForset()
920{
921 if (m_current_module->flexbodies.size() == 0)
922 {
923 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "ignoring 'forset': no matching flexbody!");
924 return;
925 }
926
927 Parser::ProcessForsetLine(m_current_module->flexbodies.back(), m_current_line, m_current_line_number);
928}
929
930void Parser::ParseDirectiveForvert()
931{
932 if (m_current_module->flexbodies.size() == 0)
933 {
934 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "ignoring 'forvert': no matching flexbody!");
935 return;
936 }
937
938 if (!this->CheckNumArguments(4)) { return; }
939
940 Forvert forvert; // The temp object.
941 forvert.line_number = m_current_line_number;
942 forvert.node_ref = this->GetArgNodeRef(1);
943 forvert.node_x = this->GetArgNodeRef(2);
944 forvert.node_y = this->GetArgNodeRef(3);
945
946 // Forver supports comma-separated vert ranges like "A-B, C, D-E"
947 // The code used with 'forset' is quirky, let's use a custom code.
948 const char* input_pos = std::strstr(m_current_line, "verts:");
949 if (!input_pos)
950 {
951 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "ignoring 'forvert': missing 'verts:' portion.");
952 return;
953 }
954
955 std::string input = input_pos;
956 std::regex pattern(R"((\d+)\s*-\s*(\d+)|(\d+))");
957 std::smatch matches;
958
959 std::string::const_iterator searchStart(input.cbegin());
960 while (std::regex_search(searchStart, input.cend(), matches, pattern))
961 {
962 if (matches[1].matched && matches[2].matched)
963 {
964 // Range found - unroll it into the `Forvert` array.
965 int start = std::stoi(matches[1].str());
966 int end = std::stoi(matches[2].str());
967 for (int i = start; i <= end; ++i)
968 {
969 forvert.vert_index = i; // Update the temp object
970 m_current_module->flexbodies.back().forvert.push_back(forvert); // Copy the temp object
971 }
972 }
973 else if (matches[3].matched)
974 {
975 // Single number found
976 forvert.vert_index = std::stoi(matches[3].str()); // Update the temp object
977 m_current_module->flexbodies.back().forvert.push_back(forvert); // Copy the temp object
978 }
979 searchStart = matches.suffix().first;
980 }
981}
982
983void Parser::ProcessForsetLine(RigDef::Flexbody& def, const std::string& _line, int line_number /*= -1*/)
984{
985 // --------------------------------------------------------------------------------------------
986 // BEWARE OF QUIRKS in the following code (they must be preserved for backwards compatibility):
987 // - a space between the 'forset' keyword and arguments is optional.
988 // - garbage characters anywhere on the line will silently add node 0 to the set.
989 // - a separator at the end of line will silently add node 0 to the set.
990 // --------------------------------------------------------------------------------------------
991
992 //parsing set definition
993 std::string line = _line;
994 char* pos = &line[0] + 6; // 'forset' = 6 characters
995 while (*pos == ' ' || *pos == ':' || *pos == ',') { pos++; } // Skip any separators
996 char* end = pos;
997 char endwas = 'G';
998 while (endwas != 0)
999 {
1000 int val1, val2; // Node numbers
1001 end = pos;
1002 while (*end != '-' && *end != ',' && *end != 0) end++;
1003 endwas = *end;
1004 *end = 0;
1005 val1 = strtoul(pos, 0, 10);
1006 if (endwas == '-')
1007 {
1008 pos = end + 1;
1009 end = pos;
1010 while (*end != ',' && *end != 0) end++;
1011 endwas = *end;
1012 *end = 0;
1013 val2 = strtoul(pos, 0, 10);
1014 // Add interval [val1-val2]
1015 def.node_list_to_import.push_back(
1016 Node::Range(
1017 Node::Ref(std::to_string(val1), val1, Node::Ref::IMPORT_STATE_IS_VALID, line_number),
1018 Node::Ref(std::to_string(val2), val2, Node::Ref::IMPORT_STATE_IS_VALID, line_number)));
1019 }
1020 else
1021 {
1022 // Add interval [val1-val1]
1023 Node::Range range_a = Node::Range(Node::Ref(std::to_string(val1), val1, Node::Ref::IMPORT_STATE_IS_VALID, line_number));
1024 def.node_list_to_import.push_back(range_a);
1025 }
1026 pos = end + 1;
1027 }
1028}
1029
1030void Parser::ParseFlaresUnified()
1031{
1032 const bool is_flares2 = (m_current_block == Keyword::FLARES2);
1033 if (! this->CheckNumArguments(is_flares2 ? 6 : 5)) { return; }
1034
1035 Flare2 flare2;
1036 int pos = 0;
1037 flare2.reference_node = this->GetArgNodeRef(pos++);
1038 flare2.node_axis_x = this->GetArgNodeRef(pos++);
1039 flare2.node_axis_y = this->GetArgNodeRef(pos++);
1040 flare2.offset.x = this->GetArgFloat (pos++);
1041 flare2.offset.y = this->GetArgFloat (pos++);
1042
1043 if (m_current_block == Keyword::FLARES2)
1044 {
1045 flare2.offset.z = this->GetArgFloat(pos++);
1046 }
1047
1048 if (m_num_args > pos) { flare2.type = this->GetArgFlareType(pos++); }
1049
1050 if (m_num_args > pos)
1051 {
1052 switch (flare2.type)
1053 {
1054 case FlareType::USER: flare2.control_number = this->GetArgInt(pos); break;
1055 case FlareType::DASHBOARD: flare2.dashboard_link = this->GetArgStr(pos); break;
1056 default: break;
1057 }
1058 pos++;
1059 }
1060
1061 if (m_num_args > pos) { flare2.blink_delay_milis = this->GetArgInt (pos++); }
1062 if (m_num_args > pos) { flare2.size = this->GetArgFloat (pos++); }
1063 if (m_num_args > pos) { flare2.material_name = this->GetArgStr (pos++); }
1064
1065 m_current_module->flares2.push_back(flare2);
1066 this->FlushPendingDocComment(m_current_module->flares2.size(), RigDef::Keyword::FLARES2);
1067}
1068
1069void Parser::ParseFlares3()
1070{
1071 const bool is_flares2 = (m_current_block == Keyword::FLARES2);
1072 if (! this->CheckNumArguments(is_flares2 ? 6 : 5)) { return; }
1073
1074 Flare3 flare3;
1075 flare3.inertia_defaults = m_user_default_inertia;
1076
1077 flare3.reference_node = this->GetArgNodeRef(0);
1078 flare3.node_axis_x = this->GetArgNodeRef(1);
1079 flare3.node_axis_y = this->GetArgNodeRef(2);
1080 flare3.offset.x = this->GetArgFloat(3);
1081 flare3.offset.y = this->GetArgFloat(4);
1082 flare3.offset.z = this->GetArgFloat(5);
1083 if (m_num_args > 6) { flare3.type = this->GetArgFlareType(6); }
1084
1085 if (m_num_args > 7)
1086 {
1087 switch (flare3.type)
1088 {
1089 case FlareType::USER: flare3.control_number = this->GetArgInt(7); break;
1090 case FlareType::DASHBOARD: flare3.dashboard_link = this->GetArgStr(7); break;
1091 default: break;
1092 }
1093 }
1094
1095 if (m_num_args > 8) { flare3.blink_delay_milis = this->GetArgInt (8); }
1096 if (m_num_args > 9) { flare3.size = this->GetArgFloat (9); }
1097 if (m_num_args > 10) { flare3.material_name = this->GetArgStr (10); }
1098
1099 m_current_module->flares3.push_back(flare3);
1100 this->FlushPendingDocComment(m_current_module->flares3.size(), RigDef::Keyword::FLARES3);
1101}
1102
1103void Parser::ParseFixes()
1104{
1105 m_current_module->fixes.push_back(this->GetArgNodeRef(0));
1106}
1107
1108void Parser::ParseExtCamera()
1109{
1110 if (! this->CheckNumArguments(2)) { return; }
1111
1112 ExtCamera extcam;
1113 extcam.mode = this->GetArgExtCameraMode(1);
1114 if (m_num_args > 2) { extcam.node = this->GetArgNodeRef(2); }
1115
1116 m_current_module->extcamera.push_back(extcam);
1117 this->FlushPendingDocComment(m_current_module->extcamera.size(), RigDef::Keyword::EXTCAMERA);
1118}
1119
1120void Parser::ParseExhaust()
1121{
1122 if (! this->CheckNumArguments(2)) { return; }
1123
1124 Exhaust exhaust;
1125 exhaust.reference_node = this->GetArgNodeRef(0);
1126 exhaust.direction_node = this->GetArgNodeRef(1);
1127
1128 // Param [2] is unused
1129 if (m_num_args > 3) { exhaust.particle_name = this->GetArgStr(3); }
1130
1131 m_current_module->exhausts.push_back(exhaust);
1132 this->FlushPendingDocComment(m_current_module->exhausts.size(), RigDef::Keyword::EXHAUSTS);
1133}
1134
1135void Parser::ParseFileFormatVersion()
1136{
1137 if (! this->CheckNumArguments(2)) { return; }
1138
1139 FileFormatVersion ffv;
1140 ffv.version = this->GetArgInt(1);
1141
1142 m_current_module->fileformatversion.push_back(ffv);
1143 m_current_block = Keyword::INVALID;
1144}
1145
1146void Parser::ParseDirectiveDefaultSkin()
1147{
1148 if (!this->CheckNumArguments(2)) { return; } // 2 items: keyword, param
1149
1150 DefaultSkin data;
1151 data.skin_name = this->GetArgStr(1);
1152 std::replace(data.skin_name.begin(), data.skin_name.end(), '_', ' ');
1153
1154 m_current_module->default_skin.push_back(data);
1155 this->FlushPendingDocComment(m_current_module->default_skin.size(), RigDef::Keyword::DEFAULT_SKIN);
1156}
1157
1158void Parser::ParseDirectiveDetacherGroup()
1159{
1160 if (! this->CheckNumArguments(2)) { return; } // 2 items: keyword, param
1161
1162 if (this->GetArgStr(1) == "end")
1163 {
1164 m_current_detacher_group = 0;
1165 }
1166 else
1167 {
1168 m_current_detacher_group = this->GetArgInt(1);
1169 }
1170}
1171
1172void Parser::ParseCruiseControl()
1173{
1174 if (! this->CheckNumArguments(3)) { return; } // keyword + 2 params
1175
1176 CruiseControl cruise_control;
1177 cruise_control.min_speed = this->GetArgFloat(1);
1178 cruise_control.autobrake = this->GetArgInt(2);
1179
1180 m_current_module->cruisecontrol.push_back(cruise_control);
1181 this->FlushPendingDocComment(m_current_module->cruisecontrol.size(), RigDef::Keyword::CRUISECONTROL);
1182}
1183
1184void Parser::ParseDescription()
1185{
1186 m_current_module->description.push_back(m_current_line); // Already trimmed
1187}
1188
1189void Parser::ParseDirectiveAddAnimation()
1190{
1191 Ogre::StringVector tokens = Ogre::StringUtil::split(m_current_line + 14, ","); // "add_animation " = 14 characters
1192 m_num_args = (int)tokens.size();
1193 if (! this->CheckNumArguments(4)) { return; }
1194
1195 if (m_current_module->props.size() == 0)
1196 {
1197 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "'add_animation' must come after prop, ignoring...");
1198 return;
1199 }
1200
1201 Animation animation;
1202 animation.ratio = this->ParseArgFloat(tokens[0].c_str());
1203 animation.lower_limit = this->ParseArgFloat(tokens[1].c_str());
1204 animation.upper_limit = this->ParseArgFloat(tokens[2].c_str());
1205
1206 for (auto itor = tokens.begin() + 3; itor != tokens.end(); ++itor)
1207 {
1208 Ogre::StringVector entry = Ogre::StringUtil::split(*itor, ":");
1209 Ogre::StringUtil::trim(entry[0]);
1210 if (entry.size() > 1) Ogre::StringUtil::trim(entry[1]);
1211
1212 const int WARN_LEN = 500;
1213 char warn_msg[WARN_LEN] = "";
1214
1215 if (entry.size() == 1) // Single keyword
1216 {
1217 if (entry[0] == "autoanimate") { animation.mode |= Animation::MODE_AUTO_ANIMATE; }
1218 else if (entry[0] == "noflip") { animation.mode |= Animation::MODE_NO_FLIP; }
1219 else if (entry[0] == "bounce") { animation.mode |= Animation::MODE_BOUNCE; }
1220 else if (entry[0] == "eventlock") { animation.mode |= Animation::MODE_EVENT_LOCK; }
1221
1222 else { snprintf(warn_msg, WARN_LEN, "Invalid keyword: %s", entry[0].c_str()); }
1223 }
1224 else if (entry.size() == 2 && (entry[0] == "mode" || entry[0] == "event" || entry[0] == "source" || entry[0] == "link"))
1225 {
1226 Ogre::StringVector values = Ogre::StringUtil::split(entry[1], "|");
1227 if (entry[0] == "mode")
1228 {
1229 for (auto itor = values.begin(); itor != values.end(); ++itor)
1230 {
1231 std::string value = *itor;
1232 Ogre::StringUtil::trim(value);
1233
1234 if (value == "x-rotation") { animation.mode |= Animation::MODE_ROTATION_X; }
1235 else if (value == "y-rotation") { animation.mode |= Animation::MODE_ROTATION_Y; }
1236 else if (value == "z-rotation") { animation.mode |= Animation::MODE_ROTATION_Z; }
1237 else if (value == "x-offset" ) { animation.mode |= Animation::MODE_OFFSET_X; }
1238 else if (value == "y-offset" ) { animation.mode |= Animation::MODE_OFFSET_Y; }
1239 else if (value == "z-offset" ) { animation.mode |= Animation::MODE_OFFSET_Z; }
1240
1241 else { snprintf(warn_msg, WARN_LEN, "Invalid 'mode': %s, ignoring...", entry[1].c_str()); }
1242 }
1243 }
1244 else if (entry[0] == "event")
1245 {
1246 animation.event_name = entry[1];
1247 Ogre::StringUtil::trim(animation.event_name);
1248 Ogre::StringUtil::toUpperCase(animation.event_name);
1249 }
1250 else if (entry[0] == "link")
1251 {
1252 animation.dash_link_name = entry[1];
1253 Ogre::StringUtil::trim(animation.dash_link_name);
1254 }
1255 else if (entry[0] == "source")
1256 {
1257 for (auto itor = values.begin(); itor != values.end(); ++itor)
1258 {
1259 std::string value = *itor;
1260 Ogre::StringUtil::trim(value);
1261
1262 if (value == "airspeed") { animation.source |= Animation::SOURCE_AIRSPEED; }
1263 else if (value == "vvi") { animation.source |= Animation::SOURCE_VERTICAL_VELOCITY; }
1264 else if (value == "altimeter100k") { animation.source |= Animation::SOURCE_ALTIMETER_100K; }
1265 else if (value == "altimeter10k") { animation.source |= Animation::SOURCE_ALTIMETER_10K; }
1266 else if (value == "altimeter1k") { animation.source |= Animation::SOURCE_ALTIMETER_1K; }
1267 else if (value == "aoa") { animation.source |= Animation::SOURCE_ANGLE_OF_ATTACK; }
1268 else if (value == "flap") { animation.source |= Animation::SOURCE_FLAP; }
1269 else if (value == "airbrake") { animation.source |= Animation::SOURCE_AIR_BRAKE; }
1270 else if (value == "roll") { animation.source |= Animation::SOURCE_ROLL; }
1271 else if (value == "pitch") { animation.source |= Animation::SOURCE_PITCH; }
1272 else if (value == "brakes") { animation.source |= Animation::SOURCE_BRAKES; }
1273 else if (value == "accel") { animation.source |= Animation::SOURCE_ACCEL; }
1274 else if (value == "clutch") { animation.source |= Animation::SOURCE_CLUTCH; }
1275 else if (value == "speedo") { animation.source |= Animation::SOURCE_SPEEDO; }
1276 else if (value == "tacho") { animation.source |= Animation::SOURCE_TACHO; }
1277 else if (value == "turbo") { animation.source |= Animation::SOURCE_TURBO; }
1278 else if (value == "parking") { animation.source |= Animation::SOURCE_PARKING; }
1279 else if (value == "shifterman1") { animation.source |= Animation::SOURCE_SHIFT_LEFT_RIGHT; }
1280 else if (value == "shifterman2") { animation.source |= Animation::SOURCE_SHIFT_BACK_FORTH; }
1281 else if (value == "sequential") { animation.source |= Animation::SOURCE_SEQUENTIAL_SHIFT; }
1282 else if (value == "shifterlin") { animation.source |= Animation::SOURCE_SHIFTERLIN; }
1283 else if (value == "autoshifterlin"){ animation.source |= Animation::SOURCE_AUTOSHIFTERLIN; }
1284 else if (value == "torque") { animation.source |= Animation::SOURCE_TORQUE; }
1285 else if (value == "heading") { animation.source |= Animation::SOURCE_HEADING; }
1286 else if (value == "difflock") { animation.source |= Animation::SOURCE_DIFFLOCK; }
1287 else if (value == "rudderboat") { animation.source |= Animation::SOURCE_BOAT_RUDDER; }
1288 else if (value == "throttleboat") { animation.source |= Animation::SOURCE_BOAT_THROTTLE; }
1289 else if (value == "steeringwheel") { animation.source |= Animation::SOURCE_STEERING_WHEEL; }
1290 else if (value == "aileron") { animation.source |= Animation::SOURCE_AILERON; }
1291 else if (value == "elevator") { animation.source |= Animation::SOURCE_ELEVATOR; }
1292 else if (value == "rudderair") { animation.source |= Animation::SOURCE_AIR_RUDDER; }
1293 else if (value == "permanent") { animation.source |= Animation::SOURCE_PERMANENT; }
1294 else if (value == "event") { animation.source |= Animation::SOURCE_EVENT; }
1295 else if (value == "dashboard") { animation.source |= Animation::SOURCE_DASHBOARD; }
1296 else if (value == "signalstalk") { animation.source |= Animation::SOURCE_SIGNALSTALK; }
1297 else if (value == "gearreverse") { animation.source |= Animation::SOURCE_GEAR_REVERSE; }
1298 else if (value == "gearneutral") { animation.source |= Animation::SOURCE_GEAR_NEUTRAL; }
1299
1300 else
1301 {
1302 Animation::MotorSource motor_source;
1303 // aeroengines...
1304 if (entry[1].compare(0, 8, "throttle") == 0)
1305 {
1306 motor_source.source = Animation::MotorSource::SOURCE_AERO_THROTTLE;
1307 motor_source.motor = this->ParseArgUint(entry[1].substr(8));
1308 }
1309 else if (entry[1].compare(0, 3, "rpm") == 0)
1310 {
1311 motor_source.source = Animation::MotorSource::SOURCE_AERO_RPM;
1312 motor_source.motor = this->ParseArgUint(entry[1].substr(3));
1313 }
1314 else if (entry[1].compare(0, 8, "aerotorq") == 0)
1315 {
1316 motor_source.source = Animation::MotorSource::SOURCE_AERO_TORQUE;
1317 motor_source.motor = this->ParseArgUint(entry[1].substr(8));
1318 }
1319 else if (entry[1].compare(0, 7, "aeropit") == 0)
1320 {
1321 motor_source.source = Animation::MotorSource::SOURCE_AERO_PITCH;
1322 motor_source.motor = this->ParseArgUint(entry[1].substr(7));
1323 }
1324 else if (entry[1].compare(0, 10, "aerostatus") == 0)
1325 {
1326 motor_source.source = Animation::MotorSource::SOURCE_AERO_STATUS;
1327 motor_source.motor = this->ParseArgUint(entry[1].substr(10));
1328 }
1329 // gears... (hack)
1330 else if (entry[1].compare(0, 4, "gear") == 0)
1331 {
1332 motor_source.source = Animation::MotorSource::SOURCE_GEAR_FORWARD;
1333 motor_source.motor = this->ParseArgUint(entry[1].substr(4));
1334 }
1335 else
1336 {
1337 snprintf(warn_msg, WARN_LEN, "Invalid 'source': %s, ignoring...", entry[1].c_str());
1338 continue;
1339 }
1340 animation.motor_sources.push_back(motor_source);
1341 }
1342 }
1343 }
1344 else
1345 {
1346 snprintf(warn_msg, WARN_LEN, "Invalid keyword: %s, ignoring...", entry[0].c_str());
1347 }
1348 }
1349 else
1350 {
1351 snprintf(warn_msg, WARN_LEN, "Invalid item: %s, ignoring...", entry[0].c_str());
1352 }
1353
1354 if (warn_msg[0] != '\0')
1355 {
1356 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
1357 fmt::format("Ignoring invalid token '{}' ({})", itor->c_str(), warn_msg));
1358 }
1359 }
1360
1361 m_current_module->props.back().animations.push_back(animation);
1362}
1363
1364void Parser::ParseAntiLockBrakes()
1365{
1366 AntiLockBrakes alb;
1367 Ogre::StringVector tokens = Ogre::StringUtil::split(m_current_line + 15, ","); // "AntiLockBrakes " = 15 characters
1368 m_num_args = (int)tokens.size();
1369 if (! this->CheckNumArguments(2)) { return; }
1370
1371 alb.regulation_force = this->ParseArgFloat(tokens[0].c_str());
1372 alb.min_speed = this->ParseArgInt (tokens[1].c_str());
1373
1374 if (tokens.size() > 3) { alb.pulse_per_sec = this->ParseArgFloat(tokens[2].c_str()); }
1375
1376 for (unsigned int i=3; i<tokens.size(); i++)
1377 {
1378 Ogre::StringVector args2 = Ogre::StringUtil::split(tokens[i], ":");
1379 Ogre::StringUtil::trim(args2[0]);
1380 Ogre::StringUtil::toLowerCase(args2[0]);
1381 if (args2[0] == "mode" && args2.size() == 2)
1382 {
1383 Ogre::StringVector attrs = Ogre::StringUtil::split(args2[1], "&");
1384 auto itor = attrs.begin();
1385 auto endi = attrs.end();
1386 for (; itor != endi; ++itor)
1387 {
1388 std::string attr = *itor;
1389 Ogre::StringUtil::trim(attr);
1390 Ogre::StringUtil::toLowerCase(attr);
1391 if (strncmp(attr.c_str(), "nodash", 6) == 0) { alb.attr_no_dashboard = true; }
1392 else if (strncmp(attr.c_str(), "notoggle", 8) == 0) { alb.attr_no_toggle = true; }
1393 else if (strncmp(attr.c_str(), "on", 2) == 0) { alb.attr_is_on = true; }
1394 else if (strncmp(attr.c_str(), "off", 3) == 0) { alb.attr_is_on = false; }
1395 }
1396 }
1397 else
1398 {
1399 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "missing mode");
1400 alb.attr_no_dashboard = false;
1401 alb.attr_no_toggle = false;
1402 alb.attr_is_on = true;
1403 }
1404 }
1405
1406 m_current_module->antilockbrakes.push_back(alb);
1407 this->FlushPendingDocComment(m_current_module->antilockbrakes.size(), RigDef::Keyword::ANTILOCKBRAKES);
1408}
1409
1410void Parser::ParseEngoption()
1411{
1412 if (! this->CheckNumArguments(1)) { return; }
1413
1414 Engoption engoption;
1415 engoption.inertia = this->GetArgFloat(0);
1416
1417 if (m_num_args > 1) { engoption.type = this->GetArgEngineType(1); }
1418 if (m_num_args > 2) { engoption.clutch_force = this->GetArgFloat(2); }
1419 if (m_num_args > 3) { engoption.shift_time = this->GetArgFloat(3); }
1420 if (m_num_args > 4) { engoption.clutch_time = this->GetArgFloat(4); }
1421 if (m_num_args > 5) { engoption.post_shift_time = this->GetArgFloat(5); }
1422 if (m_num_args > 6) { engoption.stall_rpm = this->GetArgFloat(6); }
1423 if (m_num_args > 7) { engoption.idle_rpm = this->GetArgFloat(7); }
1424 if (m_num_args > 8) { engoption.max_idle_mixture = this->GetArgFloat(8); }
1425 if (m_num_args > 9) { engoption.min_idle_mixture = this->GetArgFloat(9); }
1426 if (m_num_args > 10){ engoption.braking_torque = this->GetArgFloat(10);}
1427
1428 m_current_module->engoption.push_back(engoption);
1429 this->FlushPendingDocComment(m_current_module->engoption.size(), RigDef::Keyword::ENGOPTION);
1430}
1431
1432void Parser::ParseEngturbo()
1433{
1434 if (! this->CheckNumArguments(4)) { return; }
1435
1436 Engturbo engturbo;
1437 engturbo.version = this->GetArgInt ( 0);
1438 engturbo.tinertiaFactor = this->GetArgFloat( 1);
1439 engturbo.nturbos = this->GetArgInt ( 2);
1440 engturbo.param1 = this->GetArgFloat( 3);
1441
1442 if (m_num_args > 4) { engturbo.param2 = this->GetArgFloat( 4); }
1443 if (m_num_args > 5) { engturbo.param3 = this->GetArgFloat( 5); }
1444 if (m_num_args > 6) { engturbo.param4 = this->GetArgFloat( 6); }
1445 if (m_num_args > 7) { engturbo.param5 = this->GetArgFloat( 7); }
1446 if (m_num_args > 8) { engturbo.param6 = this->GetArgFloat( 8); }
1447 if (m_num_args > 9) { engturbo.param7 = this->GetArgFloat( 9); }
1448 if (m_num_args > 10) { engturbo.param8 = this->GetArgFloat(10); }
1449 if (m_num_args > 11) { engturbo.param9 = this->GetArgFloat(11); }
1450 if (m_num_args > 12) { engturbo.param10 = this->GetArgFloat(12); }
1451 if (m_num_args > 13) { engturbo.param11 = this->GetArgFloat(13); }
1452
1453 if (engturbo.nturbos > 4)
1454 {
1455 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "You cannot have more than 4 turbos. Fallback: using 4 instead.");
1456 engturbo.nturbos = 4;
1457 }
1458
1459 m_current_module->engturbo.push_back(engturbo);
1460 this->FlushPendingDocComment(m_current_module->engturbo.size(), RigDef::Keyword::ENGTURBO);
1461}
1462
1463void Parser::ParseEngine()
1464{
1465 if (! this->CheckNumArguments(6)) { return; }
1466
1467 Engine engine;
1468 engine.shift_down_rpm = this->GetArgFloat(0);
1469 engine.shift_up_rpm = this->GetArgFloat(1);
1470 engine.torque = this->GetArgFloat(2);
1471 engine.global_gear_ratio = this->GetArgFloat(3);
1472 engine.reverse_gear_ratio = this->GetArgFloat(4);
1473 engine.neutral_gear_ratio = this->GetArgFloat(5);
1474
1475 // Forward gears
1476 for (int i = 6; i < m_num_args; i++)
1477 {
1478 float ratio = this->GetArgFloat(i);
1479 if (ratio < 0.f)
1480 {
1481 break; // Optional terminator argument
1482 }
1483 engine.gear_ratios.push_back(ratio);
1484 }
1485
1486 if (engine.gear_ratios.size() == 0)
1487 {
1488 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "no forward gear");
1489 return;
1490 }
1491
1492 m_current_module->engine.push_back(engine);
1493 this->FlushPendingDocComment(m_current_module->engine.size(), RigDef::Keyword::ENGINE);
1494}
1495
1496void Parser::ParseContacter()
1497{
1498 if (! this->CheckNumArguments(1)) { return; }
1499
1500 m_current_module->contacters.push_back(this->GetArgNodeRef(0));
1501 this->FlushPendingDocComment(m_current_module->contacters.size(), RigDef::Keyword::CONTACTERS);
1502}
1503
1504void Parser::ParseCustomDashboardInputs()
1505{
1506 if (!this->CheckNumArguments(2)) { return; }
1507
1508 CustomDashboardInput dashVal;
1509 dashVal.name = this->GetArgStr(0);
1510 dashVal.data_type = this->GetArgDashboardInputDataType(1);
1511 if (dashVal.data_type == -1)
1512 {
1513 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
1514 fmt::format("Dashboard value \"{}\" has an invalid data type. Ignoring it.", dashVal.name));
1515 return;
1516 }
1517
1518 m_current_module->customdashboardinputs.push_back(dashVal);
1519 this->FlushPendingDocComment(m_current_module->customdashboardinputs.size(), RigDef::Keyword::CUSTOMDASHBOARDINPUTS);
1520}
1521
1522void Parser::ParseCommandsUnified()
1523{
1524 const bool is_commands2 = (m_current_block == Keyword::COMMANDS2);
1525 const int max_args = (is_commands2 ? 8 : 7);
1526 if (! this->CheckNumArguments(max_args)) { return; }
1527
1528 Command2 command2;
1529 command2.beam_defaults = m_user_beam_defaults;
1530 command2.detacher_group = m_current_detacher_group;
1531 command2.inertia_defaults = m_user_default_inertia;
1532
1533 int pos = 0;
1534 command2.nodes[0] = this->GetArgNodeRef(pos++);
1535 command2.nodes[1] = this->GetArgNodeRef(pos++);
1536 command2.shorten_rate = this->GetArgFloat (pos++);
1537
1538 if (is_commands2)
1539 {
1540 command2.lengthen_rate = this->GetArgFloat(pos++);
1541 }
1542 else
1543 {
1544 command2.lengthen_rate = command2.shorten_rate;
1545 }
1546
1547 command2.max_contraction = this->GetArgFloat(pos++);
1548 command2.max_extension = this->GetArgFloat(pos++);
1549 command2.contract_key = this->GetArgInt (pos++);
1550 command2.extend_key = this->GetArgInt (pos++);
1551
1552 if (m_num_args <= max_args) // No more args?
1553 {
1554 m_current_module->commands2.push_back(command2);
1555 return;
1556 }
1557
1558 // Parse options
1559 std::string options_str = this->GetArgStr(pos++);
1560 char winner = 0;
1561 for (auto itor = options_str.begin(); itor != options_str.end(); ++itor)
1562 {
1563 const char c = *itor;
1564 if ((winner == 0) && (c == 'o' || c == 'p' || c == 'c')) { winner = c; }
1565
1566 if (c == 'n') {} // Filler, does nothing
1567 else if (c == 'i') { command2.option_i_invisible = true; }
1568 else if (c == 'r') { command2.option_r_rope = true; }
1569 else if (c == 'f') { command2.option_f_not_faster = true; }
1570 else if (c == 'c') { command2.option_c_auto_center = true; }
1571 else if (c == 'p') { command2.option_p_1press = true; }
1572 else if (c == 'o') { command2.option_o_1press_center = true; }
1573 else
1574 {
1575 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
1576 fmt::format("ignoring unknown flag '{}'", c));
1577 }
1578 }
1579
1580 // Resolve option conflicts
1581 if (command2.option_c_auto_center && winner != 'c' && winner != 0)
1582 {
1583 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "Command cannot be one-pressed and self centering at the same time, ignoring flag 'c'");
1584 command2.option_c_auto_center = false;
1585 }
1586 char ignored = '\0';
1587 if (command2.option_o_1press_center && winner != 'o' && winner != 0)
1588 {
1589 command2.option_o_1press_center = false;
1590 ignored = 'o';
1591 }
1592 else if (command2.option_p_1press && winner != 'p' && winner != 0)
1593 {
1594 command2.option_p_1press = false;
1595 ignored = 'p';
1596 }
1597
1598 // Report conflicts
1599 if (ignored != 0 && winner == 'c')
1600 {
1601 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
1602 "Command cannot be one-pressed and self centering at the same time, ignoring flag '%c'");
1603 }
1604 else if (ignored != 0 && (winner == 'o' || winner == 'p'))
1605 {
1606 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
1607 "Command already has a one-pressed c.mode, ignoring flag '%c'");
1608 }
1609
1610 if (m_num_args > pos) { command2.description = this->GetArgStr (pos++);}
1611
1612 if (m_num_args > pos) { ParseOptionalInertia(command2.inertia, pos); pos += 4; }
1613
1614 if (m_num_args > pos) { command2.affect_engine = this->GetArgFloat(pos++);}
1615 if (m_num_args > pos) { command2.needs_engine = this->GetArgBool (pos++);}
1616 if (m_num_args > pos) { command2.plays_sound = this->GetArgBool (pos++);}
1617
1618 m_current_module->commands2.push_back(command2);
1619 this->FlushPendingDocComment(m_current_module->commands2.size(), RigDef::Keyword::COMMANDS2);
1620}
1621
1622void Parser::ParseCollisionBox()
1623{
1624 CollisionBox collisionbox;
1625
1626 Ogre::StringVector tokens = Ogre::StringUtil::split(m_current_line, ",");
1627 Ogre::StringVector::iterator iter = tokens.begin();
1628 for ( ; iter != tokens.end(); iter++)
1629 {
1630 collisionbox.nodes.push_back( this->_ParseNodeRef(*iter) );
1631 }
1632
1633 m_current_module->collisionboxes.push_back(collisionbox);
1634 this->FlushPendingDocComment(m_current_module->collisionboxes.size(), RigDef::Keyword::COLLISIONBOXES);
1635}
1636
1637void Parser::ParseCinecam()
1638{
1639 if (! this->CheckNumArguments(11)) { return; }
1640
1641 Cinecam cinecam;
1642 cinecam.beam_defaults = m_user_beam_defaults;
1643 cinecam.node_defaults = m_user_node_defaults;
1644
1645 // Required arguments
1646 cinecam.position.x = this->GetArgFloat ( 0);
1647 cinecam.position.y = this->GetArgFloat ( 1);
1648 cinecam.position.z = this->GetArgFloat ( 2);
1649 cinecam.nodes[0] = this->GetArgNodeRef( 3);
1650 cinecam.nodes[1] = this->GetArgNodeRef( 4);
1651 cinecam.nodes[2] = this->GetArgNodeRef( 5);
1652 cinecam.nodes[3] = this->GetArgNodeRef( 6);
1653 cinecam.nodes[4] = this->GetArgNodeRef( 7);
1654 cinecam.nodes[5] = this->GetArgNodeRef( 8);
1655 cinecam.nodes[6] = this->GetArgNodeRef( 9);
1656 cinecam.nodes[7] = this->GetArgNodeRef(10);
1657
1658 // Optional arguments
1659 if (m_num_args > 11) { cinecam.spring = this->GetArgFloat(11); }
1660 if (m_num_args > 12) { cinecam.damping = this->GetArgFloat(12); }
1661
1662 if (m_num_args > 13)
1663 {
1664 float value = this->GetArgFloat(13);
1665 if (value > 0.f) // Invalid input (for example illegal trailing ";pseudo-comment") parses as 0
1666 cinecam.node_mass = value;
1667 }
1668
1669 if (m_sequential_importer.IsEnabled())
1670 {
1671 m_sequential_importer.AddGeneratedNode(Keyword::CINECAM);
1672 }
1673
1674 m_current_module->cinecam.push_back(cinecam);
1675 this->FlushPendingDocComment(m_current_module->cinecam.size(), RigDef::Keyword::CINECAM);
1676}
1677
1678void Parser::ParseCameraRails()
1679{
1680 m_current_camera_rail->nodes.push_back( this->GetArgNodeRef(0) );
1681}
1682
1683void Parser::ParseBrakes()
1684{
1685 if (!this->CheckNumArguments(1)) { return; }
1686
1687 Brakes brakes;
1688 brakes.default_braking_force = this->GetArgFloat(0);
1689 if (m_num_args > 1)
1690 {
1691 brakes.parking_brake_force = this->GetArgFloat(1);
1692 }
1693 m_current_module->brakes.push_back(brakes);
1694 this->FlushPendingDocComment(m_current_module->brakes.size(), RigDef::Keyword::BRAKES);
1695}
1696
1697void Parser::ParseAxles()
1698{
1699 Axle axle;
1700
1701 Ogre::StringVector tokens = Ogre::StringUtil::split(m_current_line, ",");
1702 Ogre::StringVector::iterator iter = tokens.begin();
1703 for ( ; iter != tokens.end(); iter++)
1704 {
1705 std::smatch results;
1706 if (! std::regex_search(*iter, results, Regexes::SECTION_AXLES_PROPERTY))
1707 {
1708 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "Invalid property, ignoring whole line...");
1709 return;
1710 }
1711 // NOTE: Positions in 'results' array match E_CAPTURE*() positions (starting with 1) in the respective regex.
1712
1713 if (results[1].matched)
1714 {
1715 unsigned int wheel_index = PARSEINT(results[2]) - 1;
1716 axle.wheels[wheel_index][0] = _ParseNodeRef(results[3]);
1717 axle.wheels[wheel_index][1] = _ParseNodeRef(results[4]);
1718 }
1719 else if (results[5].matched)
1720 {
1721 this->_ParseDifferentialTypes(axle.options, results[6].str());
1722 }
1723 }
1724
1725 m_current_module->axles.push_back(axle);
1726 this->FlushPendingDocComment(m_current_module->axles.size(), RigDef::Keyword::AXLES);
1727}
1728
1729void Parser::ParseInterAxles()
1730{
1731 auto args = Ogre::StringUtil::split(m_current_line, ",");
1732 if (args.size() < 2) { return; }
1733
1734 InterAxle interaxle;
1735
1736 interaxle.a1 = this->ParseArgInt(args[0].c_str()) - 1;
1737 interaxle.a2 = this->ParseArgInt(args[1].c_str()) - 1;
1738
1739 std::smatch results;
1740 if (! std::regex_search(args[2], results, Regexes::SECTION_AXLES_PROPERTY))
1741 {
1742 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "Invalid property, ignoring whole line...");
1743 return;
1744 }
1745 // NOTE: Positions in 'results' array match E_CAPTURE*() positions (starting with 1) in the respective regex.
1746
1747 if (results[5].matched)
1748 {
1749 this->_ParseDifferentialTypes(interaxle.options, results[6].str());
1750 }
1751
1752 m_current_module->interaxles.push_back(interaxle);
1753 this->FlushPendingDocComment(m_current_module->interaxles.size(), RigDef::Keyword::INTERAXLES);
1754}
1755
1756void Parser::ParseAirbrakes()
1757{
1758 if (! this->CheckNumArguments(14)) { return; }
1759
1760 Airbrake airbrake;
1761 airbrake.reference_node = this->GetArgNodeRef( 0);
1762 airbrake.x_axis_node = this->GetArgNodeRef( 1);
1763 airbrake.y_axis_node = this->GetArgNodeRef( 2);
1764 airbrake.aditional_node = this->GetArgNodeRef( 3);
1765 airbrake.offset.x = this->GetArgFloat ( 4);
1766 airbrake.offset.y = this->GetArgFloat ( 5);
1767 airbrake.offset.z = this->GetArgFloat ( 6);
1768 airbrake.width = this->GetArgFloat ( 7);
1769 airbrake.height = this->GetArgFloat ( 8);
1770 airbrake.max_inclination_angle = this->GetArgFloat ( 9);
1771 airbrake.texcoord_x1 = this->GetArgFloat (10);
1772 airbrake.texcoord_y1 = this->GetArgFloat (11);
1773 airbrake.texcoord_x2 = this->GetArgFloat (12);
1774 airbrake.texcoord_y2 = this->GetArgFloat (13);
1775
1776 m_current_module->airbrakes.push_back(airbrake);
1777 this->FlushPendingDocComment(m_current_module->airbrakes.size(), Keyword::AIRBRAKES);
1778}
1779
1780void Parser::ParseAssetpacks()
1781{
1782 if (! this->CheckNumArguments(1)) { return; }
1783
1784 Assetpack assetpack;
1785
1786 assetpack.filename = this->GetArgStr(0);
1787
1788 m_current_module->assetpacks.push_back(assetpack);
1789 this->FlushPendingDocComment(m_current_module->assetpacks.size(), Keyword::ASSETPACKS);
1790}
1791
1792void Parser::ParseVideoCamera()
1793{
1794 if (! this->CheckNumArguments(19)) { return; }
1795
1796 VideoCamera videocamera;
1797
1798 videocamera.reference_node = this->GetArgNodeRef ( 0);
1799 videocamera.left_node = this->GetArgNodeRef ( 1);
1800 videocamera.bottom_node = this->GetArgNodeRef ( 2);
1801 videocamera.alt_reference_node = this->GetArgNullableNode( 3);
1802 videocamera.alt_orientation_node = this->GetArgNullableNode( 4);
1803 videocamera.offset.x = this->GetArgFloat ( 5);
1804 videocamera.offset.y = this->GetArgFloat ( 6);
1805 videocamera.offset.z = this->GetArgFloat ( 7);
1806 videocamera.rotation.x = this->GetArgFloat ( 8);
1807 videocamera.rotation.y = this->GetArgFloat ( 9);
1808 videocamera.rotation.z = this->GetArgFloat (10);
1809 videocamera.field_of_view = this->GetArgFloat (11);
1810 videocamera.texture_width = this->GetArgInt (12);
1811 videocamera.texture_height = this->GetArgInt (13);
1812 videocamera.min_clip_distance = this->GetArgFloat (14);
1813 videocamera.max_clip_distance = this->GetArgFloat (15);
1814 videocamera.camera_role = this->GetArgVideoCamRole(16);
1815 videocamera.camera_mode = this->GetArgInt (17);
1816 videocamera.material_name = this->GetArgStr (18);
1817
1818 if (m_num_args > 19) { videocamera.camera_name = this->GetArgStr(19); }
1819
1820 m_current_module->videocameras.push_back(videocamera);
1821 this->FlushPendingDocComment(m_current_module->videocameras.size(), Keyword::VIDEOCAMERA);
1822}
1823
1824void Parser::ParseCameras()
1825{
1826 if (! this->CheckNumArguments(3)) { return; }
1827
1828 Camera camera;
1829 camera.center_node = this->GetArgNodeRef(0);
1830 camera.back_node = this->GetArgNodeRef(1);
1831 camera.left_node = this->GetArgNodeRef(2);
1832
1833 m_current_module->cameras.push_back(camera);
1834 this->FlushPendingDocComment(m_current_module->cameras.size(), Keyword::CAMERAS);
1835}
1836
1837void Parser::ParseTurbopropsUnified()
1838{
1839 bool is_turboprop_2 = m_current_block == Keyword::TURBOPROPS2;
1840
1841 if (! this->CheckNumArguments(is_turboprop_2 ? 9 : 8)) { return; }
1842
1843 Turboprop2 turboprop;
1844
1845 turboprop.reference_node = this->GetArgNodeRef(0);
1846 turboprop.axis_node = this->GetArgNodeRef(1);
1847 turboprop.blade_tip_nodes[0] = this->GetArgNodeRef(2);
1848 turboprop.blade_tip_nodes[1] = this->GetArgNodeRef(3);
1849 turboprop.blade_tip_nodes[2] = this->GetArgNullableNode(4);
1850 turboprop.blade_tip_nodes[3] = this->GetArgNullableNode(5);
1851
1852 int offset = 0;
1853
1854 if (is_turboprop_2)
1855 {
1856 turboprop.couple_node = this->GetArgNullableNode(6);
1857
1858 offset = 1;
1859 }
1860
1861 turboprop.turbine_power_kW = this->GetArgFloat (6 + offset);
1862 turboprop.airfoil = this->GetArgStr (7 + offset);
1863
1864 m_current_module->turboprops2.push_back(turboprop);
1865 this->FlushPendingDocComment(m_current_module->turboprops2.size(), Keyword::TURBOPROPS2);
1866}
1867
1868void Parser::ParseTurbojets()
1869{
1870 if (! this->CheckNumArguments(9)) { return; }
1871
1872 Turbojet turbojet;
1873 turbojet.front_node = this->GetArgNodeRef(0);
1874 turbojet.back_node = this->GetArgNodeRef(1);
1875 turbojet.side_node = this->GetArgNodeRef(2);
1876 turbojet.is_reversable = this->GetArgInt (3);
1877 turbojet.dry_thrust = this->GetArgFloat (4);
1878 turbojet.wet_thrust = this->GetArgFloat (5);
1879 turbojet.front_diameter = this->GetArgFloat (6);
1880 turbojet.back_diameter = this->GetArgFloat (7);
1881 turbojet.nozzle_length = this->GetArgFloat (8);
1882
1883 m_current_module->turbojets.push_back(turbojet);
1884 this->FlushPendingDocComment(m_current_module->turbojets.size(), Keyword::TURBOJETS);
1885}
1886
1887void Parser::ParseTriggers()
1888{
1889 if (! this->CheckNumArguments(6)) { return; }
1890
1891 Trigger trigger;
1892 trigger.beam_defaults = m_user_beam_defaults;
1893 trigger.detacher_group = m_current_detacher_group;
1894 trigger.nodes[0] = this->GetArgNodeRef(0);
1895 trigger.nodes[1] = this->GetArgNodeRef(1);
1896 trigger.contraction_trigger_limit = this->GetArgFloat (2);
1897 trigger.expansion_trigger_limit = this->GetArgFloat (3);
1898 trigger.shortbound_trigger_action = this->GetArgInt (4);
1899 trigger.longbound_trigger_action = this->GetArgInt (5);
1900 if (m_num_args > 6) trigger.options = this->GetArgTriggerOptions(6);
1901 if (m_num_args > 7) trigger.boundary_timer = this->GetArgFloat(7);
1902
1903 m_current_module->triggers.push_back(trigger);
1904 this->FlushPendingDocComment(m_current_module->triggers.size(), Keyword::TRIGGERS);
1905}
1906
1907void Parser::ParseTorqueCurve()
1908{
1909 if (m_current_module->torquecurve.size() == 0)
1910 {
1911 m_current_module->torquecurve.push_back(TorqueCurve());
1912 }
1913
1914 Ogre::StringVector args = Ogre::StringUtil::split(m_current_line, ",");
1915
1916 if (args.size() == 1u)
1917 {
1918 m_current_module->torquecurve[0].predefined_func_name = args[0];
1919 }
1920 else if (args.size() == 2u)
1921 {
1922 TorqueCurve::Sample sample;
1923 sample.power = this->ParseArgFloat(args[0].c_str());
1924 sample.torque_percent = this->ParseArgFloat(args[1].c_str());
1925 m_current_module->torquecurve[0].samples.push_back(sample);
1926 }
1927 else
1928 {
1929 // Consistent with 0.38's parser.
1930 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "too many arguments, skipping");
1931 }
1932}
1933
1934void Parser::ParseTies()
1935{
1936 if (! this->CheckNumArguments(5)) { return; }
1937
1938 Tie tie;
1939 tie.beam_defaults = m_user_beam_defaults;
1940 tie.detacher_group = m_current_detacher_group;
1941
1942 tie.root_node = this->GetArgNodeRef(0);
1943 tie.max_reach_length = this->GetArgFloat (1);
1944 tie.auto_shorten_rate = this->GetArgFloat (2);
1945 tie.min_length = this->GetArgFloat (3);
1946 tie.max_length = this->GetArgFloat (4);
1947
1948 if (m_num_args > 5)
1949 {
1950 for (char c: this->GetArgStr(5))
1951 {
1952 switch (c)
1953 {
1954 case (char)TieOption::n_DUMMY:
1955 case (char)TieOption::v_DUMMY:
1956 break;
1957
1958 case (char)TieOption::i_INVISIBLE:
1959 tie.options |= Tie::OPTION_i_INVISIBLE;
1960 break;
1961
1962 case (char)TieOption::s_NO_SELF_LOCK:
1963 tie.options |= Tie::OPTION_s_DISABLE_SELF_LOCK;
1964 break;
1965
1966 default:
1967 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
1968 fmt::format("ignoring invalid option '{}'", c));
1969 break;
1970 }
1971 }
1972 }
1973
1974 if (m_num_args > 6) { tie.max_stress = this->GetArgFloat (6); }
1975 if (m_num_args > 7) { tie.group = this->GetArgInt (7); }
1976
1977 m_current_module->ties.push_back(tie);
1978 this->FlushPendingDocComment(m_current_module->ties.size(), Keyword::TIES);
1979}
1980
1981void Parser::ParseSoundsources()
1982{
1983 if (! this->CheckNumArguments(2)) { return; }
1984
1985 SoundSource soundsource;
1986 soundsource.node = this->GetArgNodeRef(0);
1987 soundsource.sound_script_name = this->GetArgStr(1);
1988
1989 m_current_module->soundsources.push_back(soundsource);
1990 this->FlushPendingDocComment(m_current_module->soundsources.size(), Keyword::SOUNDSOURCES);
1991}
1992
1993void Parser::ParseSoundsources2()
1994{
1995 if (! this->CheckNumArguments(3)) { return; }
1996
1997 SoundSource2 soundsource2;
1998 soundsource2.node = this->GetArgNodeRef(0);
1999 soundsource2.mode = this->GetArgInt(1);
2000 soundsource2.sound_script_name = this->GetArgStr(2);
2001
2002 if (soundsource2.mode < -2)
2003 {
2004 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
2005 fmt::format("invalid mode {}, falling back to default -2", soundsource2.mode));
2006 soundsource2.mode = -2;
2007 }
2008
2009 m_current_module->soundsources2.push_back(soundsource2);
2010 this->FlushPendingDocComment(m_current_module->soundsources2.size(), Keyword::SOUNDSOURCES2);
2011}
2012
2013void Parser::ParseSlidenodes()
2014{
2015 Ogre::StringVector args = Ogre::StringUtil::split(m_current_line, ", ");
2016 m_num_args = (int)args.size();
2017 if (! this->CheckNumArguments(2)) { return; }
2018
2019 SlideNode slidenode;
2020 slidenode.slide_node = this->_ParseNodeRef(args[0]);
2021
2022 bool in_rail_node_list = true;
2023
2024 for (auto itor = args.begin() + 1; itor != args.end(); ++itor)
2025 {
2026 char c = toupper(itor->at(0));
2027 switch (c)
2028 {
2029 case 'S':
2030 slidenode.spring_rate = this->ParseArgFloat(itor->substr(1));
2031 slidenode._spring_rate_set = true;
2032 in_rail_node_list = false;
2033 break;
2034 case 'B':
2035 slidenode.break_force = this->ParseArgFloat(itor->substr(1));
2036 slidenode._break_force_set = true;
2037 in_rail_node_list = false;
2038 break;
2039 case 'T':
2040 slidenode.tolerance = this->ParseArgFloat(itor->substr(1));
2041 slidenode._tolerance_set = true;
2042 in_rail_node_list = false;
2043 break;
2044 case 'R':
2045 slidenode.attachment_rate = this->ParseArgFloat(itor->substr(1));
2046 slidenode._attachment_rate_set = true;
2047 in_rail_node_list = false;
2048 break;
2049 case 'G':
2050 slidenode.railgroup_id = this->ParseArgFloat(itor->substr(1));
2051 slidenode._railgroup_id_set = true;
2052 in_rail_node_list = false;
2053 break;
2054 case 'D':
2055 slidenode.max_attach_dist = this->ParseArgFloat(itor->substr(1));
2056 slidenode._max_attach_dist_set = true;
2057 in_rail_node_list = false;
2058 break;
2059 case 'C':
2060 switch (itor->at(1))
2061 {
2062 case 'a':
2063 BITMASK_SET_1(slidenode.constraint_flags, SlideNode::CONSTRAINT_ATTACH_ALL);
2064 break;
2065 case 'f':
2066 BITMASK_SET_1(slidenode.constraint_flags, SlideNode::CONSTRAINT_ATTACH_FOREIGN);
2067 break;
2068 case 's':
2069 BITMASK_SET_1(slidenode.constraint_flags, SlideNode::CONSTRAINT_ATTACH_SELF);
2070 break;
2071 case 'n':
2072 BITMASK_SET_1(slidenode.constraint_flags, SlideNode::CONSTRAINT_ATTACH_NONE);
2073 break;
2074 default:
2075 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
2076 fmt::format("Ignoring invalid option '{}'", itor->at(1)));
2077 break;
2078 }
2079 in_rail_node_list = false;
2080 break;
2081 default:
2082 if (in_rail_node_list)
2083 slidenode.rail_node_ranges.push_back( _ParseNodeRef(*itor));
2084 break;
2085 }
2086 }
2087
2088 m_current_module->slidenodes.push_back(slidenode);
2089 this->FlushPendingDocComment(m_current_module->slidenodes.size(), Keyword::SLIDENODES);
2090}
2091
2092void Parser::ParseShock3()
2093{
2094 if (! this->CheckNumArguments(15)) { return; }
2095
2096 Shock3 shock_3;
2097 shock_3.beam_defaults = m_user_beam_defaults;
2098 shock_3.detacher_group = m_current_detacher_group;
2099
2100 shock_3.nodes[0] = this->GetArgNodeRef( 0);
2101 shock_3.nodes[1] = this->GetArgNodeRef( 1);
2102 shock_3.spring_in = this->GetArgFloat ( 2);
2103 shock_3.damp_in = this->GetArgFloat ( 3);
2104 shock_3.damp_in_slow = this->GetArgFloat ( 4);
2105 shock_3.split_vel_in = this->GetArgFloat ( 5);
2106 shock_3.damp_in_fast = this->GetArgFloat ( 6);
2107 shock_3.spring_out = this->GetArgFloat ( 7);
2108 shock_3.damp_out = this->GetArgFloat ( 8);
2109 shock_3.damp_out_slow = this->GetArgFloat ( 9);
2110 shock_3.split_vel_out = this->GetArgFloat (10);
2111 shock_3.damp_out_fast = this->GetArgFloat (11);
2112 shock_3.short_bound = this->GetArgFloat (12);
2113 shock_3.long_bound = this->GetArgFloat (13);
2114 shock_3.precompression = this->GetArgFloat (14);
2115
2116 if (m_num_args > 15) shock_3.options = this->GetArgShock3Options(15);
2117
2118 m_current_module->shocks3.push_back(shock_3);
2119 this->FlushPendingDocComment(m_current_module->shocks3.size(), Keyword::SHOCKS3);
2120}
2121
2122void Parser::ParseShock2()
2123{
2124 if (! this->CheckNumArguments(13)) { return; }
2125
2126 Shock2 shock_2;
2127 shock_2.beam_defaults = m_user_beam_defaults;
2128 shock_2.detacher_group = m_current_detacher_group;
2129
2130 shock_2.nodes[0] = this->GetArgNodeRef( 0);
2131 shock_2.nodes[1] = this->GetArgNodeRef( 1);
2132 shock_2.spring_in = this->GetArgFloat ( 2);
2133 shock_2.damp_in = this->GetArgFloat ( 3);
2134 shock_2.progress_factor_spring_in = this->GetArgFloat ( 4);
2135 shock_2.progress_factor_damp_in = this->GetArgFloat ( 5);
2136 shock_2.spring_out = this->GetArgFloat ( 6);
2137 shock_2.damp_out = this->GetArgFloat ( 7);
2138 shock_2.progress_factor_spring_out = this->GetArgFloat ( 8);
2139 shock_2.progress_factor_damp_out = this->GetArgFloat ( 9);
2140 shock_2.short_bound = this->GetArgFloat (10);
2141 shock_2.long_bound = this->GetArgFloat (11);
2142 shock_2.precompression = this->GetArgFloat (12);
2143
2144 if (m_num_args > 13) shock_2.options = this->GetArgShock2Options(13);
2145
2146 m_current_module->shocks2.push_back(shock_2);
2147 this->FlushPendingDocComment(m_current_module->shocks2.size(), Keyword::SHOCKS2);
2148}
2149
2150void Parser::ParseShock()
2151{
2152 if (! this->CheckNumArguments(7)) { return; }
2153
2154 Shock shock;
2155 shock.beam_defaults = m_user_beam_defaults;
2156 shock.detacher_group = m_current_detacher_group;
2157
2158 shock.nodes[0] = this->GetArgNodeRef(0);
2159 shock.nodes[1] = this->GetArgNodeRef(1);
2160 shock.spring_rate = this->GetArgFloat (2);
2161 shock.damping = this->GetArgFloat (3);
2162 shock.short_bound = this->GetArgFloat (4);
2163 shock.long_bound = this->GetArgFloat (5);
2164 shock.precompression = this->GetArgFloat (6);
2165 if (m_num_args > 7) shock.options = this->GetArgShockOptions(7);
2166
2167 m_current_module->shocks.push_back(shock);
2168 this->FlushPendingDocComment(m_current_module->shocks.size(), Keyword::SHOCKS);
2169}
2170
2171Node::Ref Parser::_ParseNodeRef(std::string const & node_id_str)
2172{
2173 if (m_sequential_importer.IsEnabled())
2174 {
2175 // Import of legacy fileformatversion
2176 int node_id_num = PARSEINT(node_id_str);
2177 if (node_id_num < 0)
2178 {
2179 node_id_num *= -1;
2180 }
2181 // Since fileformatversion is not known from the beginning of parsing, 2 states must be kept
2182 // at the same time: IMPORT_STATE and REGULAR_STATE. The outer logic must make the right pick.
2183 unsigned int flags = Node::Ref::IMPORT_STATE_IS_VALID | // Import state
2184 Node::Ref::REGULAR_STATE_IS_VALID | Node::Ref::REGULAR_STATE_IS_NAMED; // Regular state (fileformatversion >= 450)
2185 if (m_any_named_node_defined)
2186 {
2187 flags |= Node::Ref::IMPORT_STATE_MUST_CHECK_NAMED_FIRST;
2188 }
2189 return Node::Ref(node_id_str, node_id_num, flags, m_current_line_number);
2190 }
2191 else
2192 {
2193 // fileformatversion >= 450, use named-only nodes
2194 return Node::Ref(node_id_str, 0, Node::Ref::REGULAR_STATE_IS_VALID | Node::Ref::REGULAR_STATE_IS_NAMED, m_current_line_number);
2195 }
2196}
2197
2198void Parser::ParseDirectiveSetDefaultMinimass()
2199{
2200 if (! this->CheckNumArguments(2)) { return; } // Directive name + parameter
2201
2202 m_set_default_minimass = std::shared_ptr<DefaultMinimass>(new DefaultMinimass());
2203 m_set_default_minimass->min_mass_Kg = this->GetArgFloat(1);
2204}
2205
2206void Parser::ParseFlaregroupsNoImport()
2207{
2208 // ;flare_groups_no_import
2209 // ; <flaretype> <controlnumber 1-10>
2210 if (!this->CheckNumArguments(1)) { return; }
2211
2212 FlaregroupNoImport fni;
2213 fni.type = this->GetArgFlareType(0);
2214 if (m_num_args > 1)
2215 {
2216 fni.control_number = this->GetArgInt(1);
2217 if (fni.control_number < 1)
2218 {
2219 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, fmt::format("flaregroup_no_import: parameter <control_number> must be 1-10; got {}, clamping to 1", fni.control_number));
2220 }
2221 if (fni.control_number > 10)
2222 {
2223 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, fmt::format("flaregroup_no_import: parameter <control_number> must be 1-10; got {}, clamping to 10", fni.control_number));
2224 }
2225 }
2226
2227 LOG(fmt::format("[RoR|RigDef::Parser] parsed FlaregroupNoImport ({} {})", (char)fni.type, fni.control_number));
2228 m_current_module->flaregroups_no_import.push_back(fni);
2229}
2230
2231void Parser::ParseDirectiveSetInertiaDefaults()
2232{
2233 if (! this->CheckNumArguments(2)) { return; }
2234
2235 float start_delay = this->GetArgFloat(1);
2236 float stop_delay = 0;
2237 if (m_num_args > 2) { stop_delay = this->GetArgFloat(2); }
2238
2239 if (start_delay < 0 || stop_delay < 0)
2240 {
2241 m_user_default_inertia = m_ror_default_inertia; // Reset and return
2242 return;
2243 }
2244
2245 // Create
2246 Inertia* i = new Inertia(*m_user_default_inertia.get());
2247 i->start_delay_factor = start_delay;
2248 i->stop_delay_factor = stop_delay;
2249
2250 if (m_num_args > 3) { i->start_function = this->GetArgStr(3); }
2251 if (m_num_args > 4) { i->stop_function = this->GetArgStr(4); }
2252
2253 m_user_default_inertia = std::shared_ptr<Inertia>(i);
2254}
2255
2256void Parser::ParseScrewprops()
2257{
2258 if (! this->CheckNumArguments(4)) { return; }
2259
2260 Screwprop screwprop;
2261
2262 screwprop.prop_node = this->GetArgNodeRef(0);
2263 screwprop.back_node = this->GetArgNodeRef(1);
2264 screwprop.top_node = this->GetArgNodeRef(2);
2265 screwprop.power = this->GetArgFloat (3);
2266
2267 m_current_module->screwprops.push_back(screwprop);
2268 this->FlushPendingDocComment(m_current_module->screwprops.size(), Keyword::SCREWPROPS);
2269}
2270
2271void Parser::ParseScripts()
2272{
2273 if (!this->CheckNumArguments(1)) { return; }
2274
2275 Script script;
2276
2277 script.filename = this->GetArgStr(0);
2278
2279 m_current_module->scripts.push_back(script);
2280 this->FlushPendingDocComment(m_current_module->scripts.size(), Keyword::SCRIPTS);
2281}
2282
2283void Parser::ParseRotatorsUnified()
2284{
2285 if (! this->CheckNumArguments(13)) { return; }
2286
2287 Rotator2 rotator;
2288 rotator.inertia_defaults = m_user_default_inertia;
2289
2290 rotator.axis_nodes[0] = this->GetArgNodeRef( 0);
2291 rotator.axis_nodes[1] = this->GetArgNodeRef( 1);
2292 rotator.base_plate_nodes[0] = this->GetArgNodeRef( 2);
2293 rotator.base_plate_nodes[1] = this->GetArgNodeRef( 3);
2294 rotator.base_plate_nodes[2] = this->GetArgNodeRef( 4);
2295 rotator.base_plate_nodes[3] = this->GetArgNodeRef( 5);
2296 rotator.rotating_plate_nodes[0] = this->GetArgNodeRef( 6);
2297 rotator.rotating_plate_nodes[1] = this->GetArgNodeRef( 7);
2298 rotator.rotating_plate_nodes[2] = this->GetArgNodeRef( 8);
2299 rotator.rotating_plate_nodes[3] = this->GetArgNodeRef( 9);
2300 rotator.rate = this->GetArgFloat (10);
2301 rotator.spin_left_key = this->GetArgInt (11);
2302 rotator.spin_right_key = this->GetArgInt (12);
2303
2304 int offset = 0;
2305
2306 if (m_current_block == Keyword::ROTATORS2)
2307 {
2308 if (! this->CheckNumArguments(16)) { return; }
2309 if (m_num_args > 13) { rotator.rotating_force = this->GetArgFloat(13); }
2310 if (m_num_args > 14) { rotator.tolerance = this->GetArgFloat(14); }
2311 if (m_num_args > 15) { rotator.description = this->GetArgStr (15); }
2312
2313 offset = 3;
2314 }
2315
2316 this->ParseOptionalInertia(rotator.inertia, 13 + offset);
2317 if (m_num_args > 17 + offset) { rotator.engine_coupling = this->GetArgFloat(17 + offset); }
2318 if (m_num_args > 18 + offset) { rotator.needs_engine = this->GetArgBool (18 + offset); }
2319
2320 if (m_current_block == Keyword::ROTATORS2)
2321 {
2322 m_current_module->rotators2.push_back(rotator);
2323 this->FlushPendingDocComment(m_current_module->rotators2.size(), Keyword::ROTATORS2);
2324 }
2325 else
2326 {
2327 m_current_module->rotators.push_back(rotator);
2328 this->FlushPendingDocComment(m_current_module->rotators.size(), Keyword::ROTATORS);
2329 }
2330}
2331
2332void Parser::ParseFileinfo()
2333{
2334 if (! this->CheckNumArguments(2)) { return; }
2335
2336 Fileinfo fileinfo;
2337
2338 fileinfo.unique_id = this->GetArgStr(1);
2339 Ogre::StringUtil::trim(fileinfo.unique_id);
2340
2341 if (m_num_args > 2) { fileinfo.category_id = this->GetArgInt(2); }
2342 if (m_num_args > 3) { fileinfo.file_version = this->GetArgInt(3); }
2343
2344 m_current_module->fileinfo.push_back(fileinfo);
2345
2346 m_current_block = Keyword::INVALID;
2347}
2348
2349void Parser::ParseRopes()
2350{
2351 if (! this->CheckNumArguments(2)) { return; }
2352
2353 Rope rope;
2354 rope.beam_defaults = m_user_beam_defaults;
2355 rope.detacher_group = m_current_detacher_group;
2356 rope.root_node = this->GetArgNodeRef(0);
2357 rope.end_node = this->GetArgNodeRef(1);
2358
2359 if (m_num_args > 2) { rope.invisible = (this->GetArgChar(2) == 'i'); }
2360
2361 m_current_module->ropes.push_back(rope);
2362 this->FlushPendingDocComment(m_current_module->ropes.size(), Keyword::ROPES);
2363}
2364
2365void Parser::ParseRopables()
2366{
2367 if (! this->CheckNumArguments(1)) { return; }
2368
2369 Ropable ropable;
2370 ropable.node = this->GetArgNodeRef(0);
2371
2372 if (m_num_args > 1) { ropable.group = this->GetArgInt(1); }
2373 if (m_num_args > 2) { ropable.has_multilock = (this->GetArgInt(2) == 1); }
2374
2375 m_current_module->ropables.push_back(ropable);
2376 this->FlushPendingDocComment(m_current_module->ropables.size(), Keyword::ROPABLES);
2377}
2378
2379void Parser::ParseRailGroups()
2380{
2381 Ogre::StringVector args = Ogre::StringUtil::split(m_current_line, ",");
2382 m_num_args = (int)args.size();
2383 if (! this->CheckNumArguments(3)) { return; }
2384
2385 RailGroup railgroup;
2386 railgroup.id = this->ParseArgInt(args[0].c_str());
2387
2388 for (auto itor = args.begin() + 1; itor != args.end(); itor++)
2389 {
2390 railgroup.node_list.push_back( this->_ParseNodeRef(*itor));
2391 }
2392
2393 m_current_module->railgroups.push_back(railgroup);
2394 this->FlushPendingDocComment(m_current_module->railgroups.size(), Keyword::RAILGROUPS);
2395}
2396
2397void Parser::ParseProps()
2398{
2399 if (! this->CheckNumArguments(10)) { return; }
2400
2401 Prop prop;
2402 prop.reference_node = this->GetArgNodeRef(0);
2403 prop.x_axis_node = this->GetArgNodeRef(1);
2404 prop.y_axis_node = this->GetArgNodeRef(2);
2405 prop.offset.x = this->GetArgFloat (3);
2406 prop.offset.y = this->GetArgFloat (4);
2407 prop.offset.z = this->GetArgFloat (5);
2408 prop.rotation.x = this->GetArgFloat (6);
2409 prop.rotation.y = this->GetArgFloat (7);
2410 prop.rotation.z = this->GetArgFloat (8);
2411 prop.mesh_name = this->GetArgStr(9);
2412 prop.special = Parser::IdentifySpecialProp(prop.mesh_name);
2413
2414 if ((prop.special == SpecialProp::BEACON) && (m_num_args >= 14))
2415 {
2416 prop.special_prop_beacon.flare_material_name = this->GetArgStr(10);
2417 Ogre::StringUtil::trim(prop.special_prop_beacon.flare_material_name);
2418
2419 prop.special_prop_beacon.color = Ogre::ColourValue(
2420 this->GetArgFloat(11), this->GetArgFloat(12), this->GetArgFloat(13));
2421 }
2422 else if (prop.special == SpecialProp::DASHBOARD_LEFT ||
2423 prop.special == SpecialProp::DASHBOARD_RIGHT)
2424 {
2425 if (m_num_args > 10) prop.special_prop_dashboard.mesh_name = this->GetArgStr(10);
2426 if (m_num_args > 13)
2427 {
2428 prop.special_prop_dashboard.offset = Ogre::Vector3(this->GetArgFloat(11), this->GetArgFloat(12), this->GetArgFloat(13));
2429 prop.special_prop_dashboard._offset_is_set = true;
2430 }
2431 if (m_num_args > 14) prop.special_prop_dashboard.rotation_angle = this->GetArgFloat(14);
2432 }
2433
2434 m_current_module->props.push_back(prop);
2435 this->FlushPendingDocComment(m_current_module->props.size(), Keyword::PROPS);
2436}
2437
2438void Parser::ParsePistonprops()
2439{
2440 if (!this->CheckNumArguments(10)) { return; }
2441
2442 Pistonprop pistonprop;
2443 pistonprop.reference_node = this->GetArgNodeRef (0);
2444 pistonprop.axis_node = this->GetArgNodeRef (1);
2445 pistonprop.blade_tip_nodes[0] = this->GetArgNodeRef (2);
2446 pistonprop.blade_tip_nodes[1] = this->GetArgNodeRef (3);
2447 pistonprop.blade_tip_nodes[2] = this->GetArgNullableNode(4);
2448 pistonprop.blade_tip_nodes[3] = this->GetArgNullableNode(5);
2449 pistonprop.couple_node = this->GetArgNullableNode(6);
2450 pistonprop.turbine_power_kW = this->GetArgFloat (7);
2451 pistonprop.pitch = this->GetArgFloat (8);
2452 pistonprop.airfoil = this->GetArgStr (9);
2453
2454 m_current_module->pistonprops.push_back(pistonprop);
2455 this->FlushPendingDocComment(m_current_module->pistonprops.size(), Keyword::PISTONPROPS);
2456}
2457
2458void Parser::ParseParticles()
2459{
2460 if (!this->CheckNumArguments(3)) { return; }
2461
2462 Particle particle;
2463 particle.emitter_node = this->GetArgNodeRef(0);
2464 particle.reference_node = this->GetArgNodeRef(1);
2465 particle.particle_system_name = this->GetArgStr (2);
2466
2467 m_current_module->particles.push_back(particle);
2468 this->FlushPendingDocComment(m_current_module->particles.size(), Keyword::PARTICLES);
2469}
2470
2471// Static
2472void Parser::_TrimTrailingComments(std::string const & line_in, std::string & line_out)
2473{
2474 // Trim trailing comment
2475 // We need to handle a case of lines as [keyword 1, 2, 3 ;;///// Comment!]
2476 int comment_start = static_cast<int>(line_in.find_first_of(";"));
2477 if (comment_start != Ogre::String::npos)
2478 {
2479 line_out = line_in.substr(0, comment_start);
2480 return;
2481 }
2482 // The [//Comment] is harder - the '/' character may also be present in DESCRIPTION arguments!
2483 comment_start = static_cast<int>(line_in.find_last_of("/"));
2484 if (comment_start != Ogre::String::npos)
2485 {
2486 while (comment_start >= 0)
2487 {
2488 char c = line_in[comment_start - 1];
2489 if (c != '/' && c != ' ' && c != '\t')
2490 {
2491 break; // Start of comment found
2492 }
2493 --comment_start;
2494 }
2495 line_out = line_in.substr(0, comment_start);
2496 return;
2497 }
2498 // No comment found
2499 line_out = line_in;
2500}
2501
2502void Parser::ParseNodesUnified()
2503{
2504 if (! this->CheckNumArguments(4)) { return; }
2505
2506 Node node;
2507 node.node_defaults = m_user_node_defaults;
2508 node.beam_defaults = m_user_beam_defaults;
2509 node.default_minimass = m_set_default_minimass;
2510 node.detacher_group = m_current_detacher_group;
2511
2512 if (m_current_block == Keyword::NODES2)
2513 {
2514 std::string node_name = this->GetArgStr(0);
2515 node.id.setStr(node_name);
2516 if (m_sequential_importer.IsEnabled())
2517 {
2518 m_sequential_importer.AddNamedNode(node_name);
2519 }
2520 m_any_named_node_defined = true; // For import logic
2521 }
2522 else
2523 {
2524 const unsigned int node_num = this->GetArgUint(0);
2525 node.id.SetNum(node_num);
2526 if (m_sequential_importer.IsEnabled())
2527 {
2528 m_sequential_importer.AddNumberedNode(node_num);
2529 }
2530 }
2531
2532 node.position.x = this->GetArgFloat(1);
2533 node.position.y = this->GetArgFloat(2);
2534 node.position.z = this->GetArgFloat(3);
2535 if (m_num_args > 4)
2536 {
2537 node.options = this->GetArgNodeOptions(4);
2538 }
2539 if (m_num_args > 5)
2540 {
2541 if (node.options & Node::OPTION_l_LOAD_WEIGHT)
2542 {
2543 node.load_weight_override = this->GetArgFloat(5);
2544 node._has_load_weight_override = true;
2545 }
2546 else
2547 {
2548 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
2549 "Node has load-weight-override value specified, but option 'l' is not present. Ignoring value...");
2550 }
2551 }
2552
2553 m_current_module->nodes.push_back(node);
2554 this->FlushPendingDocComment(m_current_module->nodes.size(), Keyword::NODES);
2555}
2556
2557void Parser::ParseMinimass()
2558{
2559 if (! this->CheckNumArguments(1)) { return; }
2560
2561 Minimass mm;
2562 mm.global_min_mass_Kg = this->GetArgFloat(0);
2563 if (m_num_args > 1) { mm.option = this->GetArgMinimassOption(1); }
2564
2565 m_current_module->minimass.push_back(mm);
2566 m_current_block = Keyword::INVALID;
2567}
2568
2569void Parser::ParseFlexBodyWheel()
2570{
2571 if (! this->CheckNumArguments(16)) { return; }
2572
2573 FlexBodyWheel flexbody_wheel;
2574 flexbody_wheel.node_defaults = m_user_node_defaults;
2575 flexbody_wheel.beam_defaults = m_user_beam_defaults;
2576
2577 flexbody_wheel.tyre_radius = this->GetArgFloat ( 0);
2578 flexbody_wheel.rim_radius = this->GetArgFloat ( 1);
2579 flexbody_wheel.width = this->GetArgFloat ( 2);
2580 flexbody_wheel.num_rays = this->GetArgInt ( 3);
2581 flexbody_wheel.nodes[0] = this->GetArgNodeRef ( 4);
2582 flexbody_wheel.nodes[1] = this->GetArgNodeRef ( 5);
2583 flexbody_wheel.rigidity_node = this->GetArgRigidityNode ( 6);
2584 flexbody_wheel.braking = this->GetArgBraking ( 7);
2585 flexbody_wheel.propulsion = this->GetArgPropulsion ( 8);
2586 flexbody_wheel.reference_arm_node = this->GetArgNodeRef ( 9);
2587 flexbody_wheel.mass = this->GetArgFloat (10);
2588 flexbody_wheel.tyre_springiness = this->GetArgFloat (11);
2589 flexbody_wheel.tyre_damping = this->GetArgFloat (12);
2590 flexbody_wheel.rim_springiness = this->GetArgFloat (13);
2591 flexbody_wheel.rim_damping = this->GetArgFloat (14);
2592 flexbody_wheel.side = this->GetArgWheelSide (15);
2593
2594 if (m_num_args > 16) { flexbody_wheel.rim_mesh_name = this->GetArgStr(16); }
2595 if (m_num_args > 17) { flexbody_wheel.tyre_mesh_name = this->GetArgStr(17); }
2596
2597 if (m_sequential_importer.IsEnabled())
2598 {
2599 m_sequential_importer.GenerateNodesForWheel(Keyword::FLEXBODYWHEELS, flexbody_wheel.num_rays, flexbody_wheel.rigidity_node.IsValidAnyState());
2600 }
2601
2602 m_current_module->flexbodywheels.push_back(flexbody_wheel);
2603 this->FlushPendingDocComment(m_current_module->flexbodywheels.size(), Keyword::FLEXBODYWHEELS);
2604}
2605
2606void Parser::ParseMaterialFlareBindings()
2607{
2608 if (! this->CheckNumArguments(2)) { return; }
2609
2610 MaterialFlareBinding binding;
2611 binding.flare_number = this->GetArgInt(0);
2612 binding.material_name = this->GetArgStr(1);
2613
2614 m_current_module->materialflarebindings.push_back(binding);
2615 this->FlushPendingDocComment(m_current_module->materialflarebindings.size(), Keyword::MATERIALFLAREBINDINGS);
2616}
2617
2618void Parser::ParseManagedMaterials()
2619{
2620 if (! this->CheckNumArguments(2)) { return; }
2621
2622 ManagedMaterial managed_mat;
2623 managed_mat.options = m_current_managed_material_options;
2624 managed_mat.name = this->GetArgStr(0);
2625 managed_mat.type = this->GetArgManagedMatType(1);
2626
2627 if (managed_mat.type != ManagedMaterialType::INVALID)
2628 {
2629 if (! this->CheckNumArguments(3)) { return; }
2630
2631 managed_mat.diffuse_map = this->GetArgStr(2);
2632
2633 if (managed_mat.type == ManagedMaterialType::MESH_STANDARD ||
2634 managed_mat.type == ManagedMaterialType::MESH_TRANSPARENT)
2635 {
2636 if (m_num_args > 3) { managed_mat.specular_map = this->GetArgManagedTex(3); }
2637 }
2638 else if (managed_mat.type == ManagedMaterialType::FLEXMESH_STANDARD ||
2639 managed_mat.type == ManagedMaterialType::FLEXMESH_TRANSPARENT)
2640 {
2641 if (m_num_args > 3) { managed_mat.damaged_diffuse_map = this->GetArgManagedTex(3); }
2642 if (m_num_args > 4) { managed_mat.specular_map = this->GetArgManagedTex(4); }
2643 }
2644
2645 m_current_module->managedmaterials.push_back(managed_mat);
2646 this->FlushPendingDocComment(m_current_module->managedmaterials.size(), Keyword::MANAGEDMATERIALS);
2647 }
2648}
2649
2650void Parser::ParseLockgroups()
2651{
2652 if (! this->CheckNumArguments(2)) { return; } // Lockgroup num. + at least 1 node...
2653
2654 Lockgroup lockgroup;
2655 lockgroup.number = this->GetArgInt(0);
2656
2657 for (int i = 1; i < m_num_args; ++i)
2658 {
2659 lockgroup.nodes.push_back(this->GetArgNodeRef(i));
2660 }
2661
2662 m_current_module->lockgroups.push_back(lockgroup);
2663 this->FlushPendingDocComment(m_current_module->lockgroups.size(), Keyword::LOCKGROUPS);
2664}
2665
2666void Parser::ParseHydros()
2667{
2668 if (! this->CheckNumArguments(3)) { return; }
2669
2670 Hydro hydro;
2671 hydro.inertia_defaults = m_user_default_inertia;
2672 hydro.detacher_group = m_current_detacher_group;
2673 hydro.beam_defaults = m_user_beam_defaults;
2674
2675 hydro.nodes[0] = this->GetArgNodeRef(0);
2676 hydro.nodes[1] = this->GetArgNodeRef(1);
2677 hydro.lenghtening_factor = this->GetArgFloat (2);
2678
2679 if (m_num_args > 3) { hydro.options = this->GetArgHydroOptions(3); }
2680
2681 if (!hydro.options)
2682 {
2683 hydro.options |= Hydro::OPTION_n_INPUT_NORMAL;
2684 }
2685
2686 this->ParseOptionalInertia(hydro.inertia, 4);
2687
2688 m_current_module->hydros.push_back(hydro);
2689 this->FlushPendingDocComment(m_current_module->hydros.size(), Keyword::HYDROS);
2690}
2691
2692void Parser::ParseOptionalInertia(Inertia & inertia, int index)
2693{
2694 if (m_num_args > index) { inertia.start_delay_factor = this->GetArgFloat(index++); }
2695 if (m_num_args > index) { inertia.stop_delay_factor = this->GetArgFloat(index++); }
2696 if (m_num_args > index) { inertia.start_function = this->GetArgStr (index++); }
2697 if (m_num_args > index) { inertia.stop_function = this->GetArgStr (index++); }
2698}
2699
2700void Parser::_ParseDifferentialTypes(DifferentialTypeVec& diff_types, std::string const& options_str)
2701{
2702 for (char c: options_str)
2703 {
2704 switch(c)
2705 {
2706 case (char)DifferentialType::o_OPEN:
2707 case (char)DifferentialType::l_LOCKED:
2708 case (char)DifferentialType::s_SPLIT:
2709 case (char)DifferentialType::v_VISCOUS:
2710 diff_types.push_back(DifferentialType(c));
2711 break;
2712
2713 default:
2714 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
2715 fmt::format("ignoring invalid differential type '{}'", c));
2716 break;
2717 }
2718 }
2719}
2720
2721void Parser::ParseBeams()
2722{
2723 if (! this->CheckNumArguments(2)) { return; }
2724
2725 Beam beam;
2726 beam.defaults = m_user_beam_defaults;
2727 beam.detacher_group = m_current_detacher_group;
2728
2729 beam.nodes[0] = this->GetArgNodeRef(0);
2730 beam.nodes[1] = this->GetArgNodeRef(1);
2731 if (m_num_args > 2) beam.options = this->GetArgBeamOptions(2);
2732
2733 if ((m_num_args > 3) && BITMASK_IS_1(beam.options, Beam::OPTION_s_SUPPORT))
2734 {
2735 float support_break_limit = 0.0f;
2736 float support_break_factor = this->GetArgInt(3);
2737 if (support_break_factor > 0.0f)
2738 {
2739 support_break_limit = support_break_factor;
2740 }
2741 beam.extension_break_limit = support_break_limit;
2742 beam._has_extension_break_limit = true;
2743 }
2744
2745 m_current_module->beams.push_back(beam);
2746 this->FlushPendingDocComment(m_current_module->beams.size(), Keyword::BEAMS);
2747}
2748
2749void Parser::ParseAnimator()
2750{
2751 auto args = Ogre::StringUtil::split(m_current_line, ",");
2752 if (args.size() < 4) { return; }
2753
2754 Animator animator;
2755 animator.inertia_defaults = m_user_default_inertia;
2756 animator.beam_defaults = m_user_beam_defaults;
2757 animator.detacher_group = m_current_detacher_group;
2758
2759 animator.nodes[0] = this->_ParseNodeRef(args[0]);
2760 animator.nodes[1] = this->_ParseNodeRef(args[1]);
2761 animator.lenghtening_factor = this->ParseArgFloat(args[2]);
2762
2763 // Parse options; Just use the split/trim/compare method
2764 Ogre::StringVector attrs = Ogre::StringUtil::split(args[3], "|");
2765
2766 auto itor = attrs.begin();
2767 auto endi = attrs.end();
2768 for (; itor != endi; ++itor)
2769 {
2770 Ogre::String token = *itor;
2771 Ogre::StringUtil::trim(token);
2772 std::smatch results;
2773 bool is_shortlimit = false;
2774
2775 // Numbered keywords
2776 if (std::regex_search(token, results, Regexes::PARSE_ANIMATORS_NUMBERED_KEYWORD))
2777 {
2778 if (results[1] == "throttle") animator.aero_animator.flags |= AeroAnimator::OPTION_THROTTLE;
2779 else if (results[1] == "rpm") animator.aero_animator.flags |= AeroAnimator::OPTION_RPM;
2780 else if (results[1] == "aerotorq") animator.aero_animator.flags |= AeroAnimator::OPTION_TORQUE;
2781 else if (results[1] == "aeropit") animator.aero_animator.flags |= AeroAnimator::OPTION_PITCH;
2782 else if (results[1] == "aerostatus") animator.aero_animator.flags |= AeroAnimator::OPTION_STATUS;
2783
2784 animator.aero_animator.engine_idx = this->ParseArgUint(results[2].str().c_str()) - 1;
2785 }
2786 else if ((is_shortlimit = (token.compare(0, 10, "shortlimit") == 0)) || (token.compare(0, 9, "longlimit") == 0))
2787 {
2788 Ogre::StringVector fields = Ogre::StringUtil::split(token, ":");
2789 if (fields.size() > 1)
2790 {
2791 if (is_shortlimit)
2792 {
2793 animator.short_limit = std::strtod(fields[1].c_str(), nullptr);
2794 animator.flags |= Animator::OPTION_SHORT_LIMIT;
2795 }
2796 else
2797 {
2798 animator.long_limit = std::strtod(fields[1].c_str(), nullptr);
2799 animator.flags |= Animator::OPTION_LONG_LIMIT;
2800 }
2801 }
2802 }
2803 else
2804 {
2805 // Standalone keywords
2806 if (token == "vis") animator.flags |= Animator::OPTION_VISIBLE;
2807 else if (token == "inv") animator.flags |= Animator::OPTION_INVISIBLE;
2808 else if (token == "airspeed") animator.flags |= Animator::OPTION_AIRSPEED;
2809 else if (token == "vvi") animator.flags |= Animator::OPTION_VERTICAL_VELOCITY;
2810 else if (token == "altimeter100k") animator.flags |= Animator::OPTION_ALTIMETER_100K;
2811 else if (token == "altimeter10k") animator.flags |= Animator::OPTION_ALTIMETER_10K;
2812 else if (token == "altimeter1k") animator.flags |= Animator::OPTION_ALTIMETER_1K;
2813 else if (token == "aoa") animator.flags |= Animator::OPTION_ANGLE_OF_ATTACK;
2814 else if (token == "flap") animator.flags |= Animator::OPTION_FLAP;
2815 else if (token == "airbrake") animator.flags |= Animator::OPTION_AIR_BRAKE;
2816 else if (token == "roll") animator.flags |= Animator::OPTION_ROLL;
2817 else if (token == "pitch") animator.flags |= Animator::OPTION_PITCH;
2818 else if (token == "brakes") animator.flags |= Animator::OPTION_BRAKES;
2819 else if (token == "accel") animator.flags |= Animator::OPTION_ACCEL;
2820 else if (token == "clutch") animator.flags |= Animator::OPTION_CLUTCH;
2821 else if (token == "speedo") animator.flags |= Animator::OPTION_SPEEDO;
2822 else if (token == "tacho") animator.flags |= Animator::OPTION_TACHO;
2823 else if (token == "turbo") animator.flags |= Animator::OPTION_TURBO;
2824 else if (token == "parking") animator.flags |= Animator::OPTION_PARKING;
2825 else if (token == "shifterman1") animator.flags |= Animator::OPTION_SHIFT_LEFT_RIGHT;
2826 else if (token == "shifterman2") animator.flags |= Animator::OPTION_SHIFT_BACK_FORTH;
2827 else if (token == "sequential") animator.flags |= Animator::OPTION_SEQUENTIAL_SHIFT;
2828 else if (token == "shifterlin") animator.flags |= Animator::OPTION_GEAR_SELECT;
2829 else if (token == "torque") animator.flags |= Animator::OPTION_TORQUE;
2830 else if (token == "difflock") animator.flags |= Animator::OPTION_DIFFLOCK;
2831 else if (token == "rudderboat") animator.flags |= Animator::OPTION_BOAT_RUDDER;
2832 else if (token == "throttleboat") animator.flags |= Animator::OPTION_BOAT_THROTTLE;
2833 }
2834 }
2835
2836 m_current_module->animators.push_back(animator);
2837 this->FlushPendingDocComment(m_current_module->animators.size(), Keyword::ANIMATORS);
2838}
2839
2840void Parser::ParseAuthor()
2841{
2842 if (! this->CheckNumArguments(2)) { return; }
2843
2844 Author author;
2845 if (m_num_args > 1) { author.type = this->GetArgStr(1); }
2846 if (m_num_args > 2) { author.forum_account_id = this->GetArgInt(2); author._has_forum_account = true; }
2847 if (m_num_args > 3) { author.name = this->GetArgStr(3); }
2848 if (m_num_args > 4) { author.email = this->GetArgStr(4); }
2849
2850 m_current_module->author.push_back(author);
2851 this->FlushPendingDocComment(m_current_module->author.size(), Keyword::AUTHOR);
2852 m_current_block = Keyword::INVALID;
2853}
2854
2855// --------------------------------------------------------------------------
2856// Utilities
2857// --------------------------------------------------------------------------
2858
2859void Parser::LogMessage(Console::MessageType type, std::string const& msg)
2860{
2861 App::GetConsole()->putMessage(
2862 Console::CONSOLE_MSGTYPE_ACTOR,
2863 type,
2864 fmt::format("{}:{} ({}): {}",
2865 m_filename, m_current_line_number, KeywordToString(m_log_keyword), msg));
2866}
2867
2868Keyword Parser::IdentifyKeyword(const std::string& line)
2869{
2870 // Search and ignore lettercase
2871 std::smatch results;
2872 std::regex_search(line, results, Regexes::IDENTIFY_KEYWORD_IGNORE_CASE); // Always returns true.
2873
2874 // The 'results' array contains a complete match at positon [0] and sub-matches starting with [1],
2875 // so we get exact positions in Regexes::IDENTIFY_KEYWORD, which again match Keyword enum members
2876 for (unsigned int i = 1; i < results.size(); i++)
2877 {
2878 std::ssub_match sub = results[i];
2879 if (sub.matched)
2880 {
2881 // Build enum value directly from result offset
2882 return Keyword(i);
2883 }
2884 }
2885
2886 return Keyword::INVALID;
2887}
2888
2889void Parser::Prepare()
2890{
2891 m_current_block = Keyword::INVALID;
2892 m_current_line_number = 1;
2893 m_definition = RigDef::DocumentPtr(new Document());
2894 m_any_named_node_defined = false;
2895 m_current_detacher_group = 0; // Global detacher group
2896
2897 m_user_default_inertia = m_ror_default_inertia;
2898 m_user_node_defaults = m_ror_node_defaults;
2899 m_current_managed_material_options = ManagedMaterialsOptions();
2900
2901 m_user_beam_defaults = std::shared_ptr<BeamDefaults>(new BeamDefaults);
2902 m_user_beam_defaults->springiness = DEFAULT_SPRING;
2903 m_user_beam_defaults->damping_constant = DEFAULT_DAMP;
2904 m_user_beam_defaults->deformation_threshold = BEAM_DEFORM;
2905 m_user_beam_defaults->breaking_threshold = BEAM_BREAK;
2906 m_user_beam_defaults->visual_beam_diameter = DEFAULT_BEAM_DIAMETER;
2907
2908 m_root_module = m_definition->root_module;
2909 m_current_module = m_definition->root_module;
2910
2911 m_sequential_importer.Init(true); // Enabled=true
2912}
2913
2914void Parser::BeginBlock(Keyword keyword)
2915{
2916 if (keyword == Keyword::INVALID) // also means 'end'
2917 {
2918 // flush staged submesh, if any
2919 if (m_current_submesh != nullptr)
2920 {
2921 m_current_module->submeshes.push_back(*m_current_submesh);
2922 m_current_submesh.reset(); // Set to nullptr
2923 }
2924
2925 // flush staged camerarail, if any
2926 if (m_current_camera_rail != nullptr)
2927 {
2928 if (m_current_camera_rail->nodes.size() == 0)
2929 {
2930 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING, "Empty section 'camerarail', ignoring...");
2931 }
2932 else
2933 {
2934 m_current_module->camerarail.push_back(*m_current_camera_rail);
2935 m_current_camera_rail.reset();
2936 }
2937 }
2938 }
2939 else if (keyword == Keyword::CAMERARAIL)
2940 {
2941 this->BeginBlock(Keyword::INVALID); // flush staged rail
2942 m_current_camera_rail = std::shared_ptr<CameraRail>( new CameraRail() );
2943 }
2944 m_current_block = keyword;
2945}
2946
2947void Parser::ProcessChangeModuleLine(Keyword keyword)
2948{
2949 // Determine and verify new module
2950 std::string new_module_name;
2951 if (keyword == Keyword::END_SECTION)
2952 {
2953 if (m_current_module == m_root_module)
2954 {
2955 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "Misplaced keyword 'end_section' (already in root module), ignoring...");
2956 return;
2957 }
2958 new_module_name = ROOT_MODULE_NAME;
2959 }
2960 else if (keyword == Keyword::SECTION)
2961 {
2962 if (!this->CheckNumArguments(3)) // Syntax: "section VERSION NAME"; VERSION is unused
2963 {
2964 return; // Error already reported
2965 }
2966
2967 new_module_name = this->GetArgStr(2);
2968 if (new_module_name == m_current_module->name)
2969 {
2970 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR, "Attempt to re-enter current module, ignoring...");
2971 return;
2972 }
2973 }
2974
2975 // Perform the switch
2976 this->BeginBlock(Keyword::INVALID);
2977
2978 if (new_module_name == ROOT_MODULE_NAME)
2979 {
2980 m_current_module = m_root_module;
2981 return;
2982 }
2983
2984 auto search_itor = m_definition->user_modules.find(new_module_name);
2985 if (search_itor != m_definition->user_modules.end())
2986 {
2987 m_current_module = search_itor->second;
2988 }
2989 else
2990 {
2991 m_current_module = std::make_shared<Document::Module>(new_module_name);
2992 m_definition->user_modules.insert(std::make_pair(new_module_name, m_current_module));
2993 }
2994}
2995
2996void Parser::FlushPendingDocComment(size_t vectorlen, RigDef::Keyword keyword)
2997{
2998 if (m_pending_doc_comment.comment_text == "" || vectorlen == 0)
2999 {
3000 return;
3001 }
3002
3003 m_pending_doc_comment.commented_keyword = keyword;
3004 m_pending_doc_comment.commented_datapos = static_cast<int>(vectorlen - 1);
3005 m_current_module->_comments.push_back(m_pending_doc_comment);
3006
3007 m_pending_doc_comment = DocComment();
3008}
3009
3014
3015void Parser::ParseDirectiveSectionConfig()
3016{
3017 // FIXME: restore this, see branch 'retro-0407'
3018}
3019
3020void Parser::Finalize()
3021{
3022 this->BeginBlock(Keyword::INVALID);
3023
3024 if (m_sequential_importer.IsEnabled())
3025 {
3026 m_sequential_importer.Process( m_definition );
3027 }
3028}
3029
3030std::string Parser::GetArgStr(int index)
3031{
3032 return std::string(m_args[index].start, m_args[index].length);
3033}
3034
3035char Parser::GetArgChar(int index)
3036{
3037 return *(m_args[index].start);
3038}
3039
3040WheelSide Parser::GetArgWheelSide(int index)
3041{
3042 char c = this->GetArgChar(index);
3043 switch (c)
3044 {
3045 case (char)WheelSide::RIGHT:
3046 case (char)WheelSide::LEFT:
3047 return WheelSide(c);
3048
3049 default:
3050 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3051 fmt::format("Bad arg~{} 'side' (value: {}), parsing as 'l' for backwards compatibility.", index + 1, c));
3052 return WheelSide::LEFT;
3053 }
3054}
3055
3056long Parser::GetArgLong(int index)
3057{
3058 errno = 0;
3059 char* out_end = nullptr;
3060 long res = std::strtol(m_args[index].start, &out_end, 10);
3061 if (errno != 0)
3062 {
3063 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
3064 fmt::format("Cannot parse argument [{}] as integer, errno: {}", index + 1, errno));
3065 return 0; // Compatibility
3066 }
3067 if (out_end == m_args[index].start)
3068 {
3069 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
3070 fmt::format("Argument [{}] is not valid integer", index + 1));
3071 return 0; // Compatibility
3072 }
3073 else if (out_end != (m_args[index].start + m_args[index].length))
3074 {;
3075 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3076 fmt::format("Integer argument [{}] has invalid trailing characters", index + 1));
3077 }
3078 return res;
3079}
3080
3081int Parser::GetArgInt(int index)
3082{
3083 return static_cast<int>(this->GetArgLong(index));
3084}
3085
3086Node::Ref Parser::GetArgRigidityNode(int index)
3087{
3088 std::string rigidity_node = this->GetArgStr(index);
3089 if (rigidity_node != "9999") // Special null value
3090 {
3091 return this->GetArgNodeRef(index);
3092 }
3093 return Node::Ref(); // Defaults to invalid ref
3094}
3095
3096RoR::WheelPropulsion Parser::GetArgPropulsion(int index)
3097{
3098 int p = this->GetArgInt(index);
3099 switch (p)
3100 {
3101 case (int)WheelPropulsion::NONE:
3102 case (int)WheelPropulsion::FORWARD:
3103 case (int)WheelPropulsion::BACKWARD:
3104 return WheelPropulsion(p);
3105
3106 default:
3107 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
3108 fmt::format("Bad value of param ~{} (propulsion), using 0 (no propulsion)", index + 1));
3109 return WheelPropulsion::NONE;
3110 }
3111}
3112
3113RoR::WheelBraking Parser::GetArgBraking(int index)
3114{
3115 int b = this->GetArgInt(index);
3116 switch (b)
3117 {
3118 case (int)WheelBraking::NONE:
3119 case (int)WheelBraking::FOOT_HAND:
3120 case (int)WheelBraking::FOOT_HAND_SKID_LEFT:
3121 case (int)WheelBraking::FOOT_HAND_SKID_RIGHT:
3122 case (int)WheelBraking::FOOT_ONLY:
3123 return WheelBraking(b);
3124
3125 default:
3126 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
3127 fmt::format("Bad value of param ~{} (braking), using 0 (not braked)", index + 1));
3128 return WheelBraking::NONE;
3129 }
3130}
3131
3132Node::Ref Parser::GetArgNodeRef(int index)
3133{
3134 return this->_ParseNodeRef(this->GetArgStr(index));
3135}
3136
3137Node::Ref Parser::GetArgNullableNode(int index)
3138{
3139 if (! (Ogre::StringConverter::parseReal(this->GetArgStr(index)) == -1.f))
3140 {
3141 return this->GetArgNodeRef(index);
3142 }
3143 return Node::Ref(); // Defaults to empty ref.
3144}
3145
3146unsigned Parser::GetArgUint(int index)
3147{
3148 return static_cast<unsigned>(this->GetArgLong(index));
3149}
3150
3151FlareType Parser::GetArgFlareType(int index)
3152{
3153 char in = this->GetArgChar(index);
3154 switch (in)
3155 {
3156 // Front lights
3157 case (char)FlareType::HEADLIGHT:
3158 case (char)FlareType::HIGH_BEAM:
3159 case (char)FlareType::FOG_LIGHT:
3160 // Rear lighs
3161 case (char)FlareType::TAIL_LIGHT:
3162 case (char)FlareType::BRAKE_LIGHT:
3163 case (char)FlareType::REVERSE_LIGHT:
3164 // Special lights
3165 case (char)FlareType::SIDELIGHT:
3166 case (char)FlareType::BLINKER_LEFT:
3167 case (char)FlareType::BLINKER_RIGHT:
3168 case (char)FlareType::USER:
3169 case (char)FlareType::DASHBOARD:
3170 return FlareType(in);
3171
3172 default:
3173 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3174 fmt::format("Invalid flare type '{}', falling back to type 'f' (front light)...", in));
3175 return FlareType::HEADLIGHT;
3176 }
3177}
3178
3179ExtCameraMode Parser::GetArgExtCameraMode(int index)
3180{
3181 std::string str = this->GetArgStr(index);
3182 if (str == "classic") return ExtCameraMode::CLASSIC;
3183 if (str == "cinecam") return ExtCameraMode::CINECAM;
3184 if (str == "node") return ExtCameraMode::NODE;
3185
3186 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3187 fmt::format("Invalid ExtCameraMode '{}', falling back to type 'classic'...", str));
3188 return ExtCameraMode::CLASSIC;
3189}
3190
3191float Parser::GetArgFloat(int index)
3192{
3193 return (float) Ogre::StringConverter::parseReal(this->GetArgStr(index), 0.f);
3194}
3195
3196float Parser::ParseArgFloat(const char* str)
3197{
3198 return (float) Ogre::StringConverter::parseReal(str, 0.f);
3199}
3200
3201float Parser::ParseArgFloat(std::string const & str)
3202{
3203 return this->ParseArgFloat(str.c_str());
3204}
3205
3206unsigned Parser::ParseArgUint(const char* str)
3207{
3208 errno = 0;
3209 long res = std::strtol(str, nullptr, 10);
3210 if (errno != 0)
3211 {
3212 this->LogMessage(Console::CONSOLE_SYSTEM_ERROR,
3213 fmt::format("Cannot parse argument '{}' as int, errno: {}", str, errno));
3214 return 0.f; // Compatibility
3215 }
3216 return static_cast<unsigned>(res);
3217}
3218
3219unsigned Parser::ParseArgUint(std::string const & str)
3220{
3221 return this->ParseArgUint(str.c_str());
3222}
3223
3224int Parser::ParseArgInt(const char* str)
3225{
3226 return static_cast<int>(this->ParseArgUint(str));
3227}
3228
3229bool Parser::GetArgBool(int index)
3230{
3231 return Ogre::StringConverter::parseBool(this->GetArgStr(index));
3232}
3233
3234WingControlSurface Parser::GetArgWingSurface(int index)
3235{
3236 char c = this->GetArgChar(index);
3237 switch (c)
3238 {
3239 case (char)WingControlSurface::n_NONE:
3240 case (char)WingControlSurface::a_RIGHT_AILERON:
3241 case (char)WingControlSurface::b_LEFT_AILERON:
3242 case (char)WingControlSurface::f_FLAP:
3243 case (char)WingControlSurface::e_ELEVATOR:
3244 case (char)WingControlSurface::r_RUDDER:
3245 case (char)WingControlSurface::S_RIGHT_HAND_STABILATOR:
3246 case (char)WingControlSurface::T_LEFT_HAND_STABILATOR:
3247 case (char)WingControlSurface::c_RIGHT_ELEVON:
3248 case (char)WingControlSurface::d_LEFT_ELEVON:
3249 case (char)WingControlSurface::g_RIGHT_FLAPERON:
3250 case (char)WingControlSurface::h_LEFT_FLAPERON:
3251 case (char)WingControlSurface::U_RIGHT_HAND_TAILERON:
3252 case (char)WingControlSurface::V_LEFT_HAND_TAILERON:
3253 case (char)WingControlSurface::i_RIGHT_RUDDERVATOR:
3254 case (char)WingControlSurface::j_LEFT_RUDDERVATOR:
3255 return WingControlSurface(c);
3256
3257 default:
3258 fmt::format("invalid WingControlSurface '{}', falling back to 'n' (none)", c);
3259 return WingControlSurface::n_NONE;
3260 }
3261}
3262
3263std::string Parser::GetArgManagedTex(int index)
3264{
3265 std::string tex_name = this->GetArgStr(index);
3266 return (tex_name.at(0) != '-') ? tex_name : "";
3267}
3268
3269MinimassOption Parser::GetArgMinimassOption(int index)
3270{
3271 switch (this->GetArgStr(index)[0])
3272 {
3273 case (char)MinimassOption::l_SKIP_LOADED:
3274 return MinimassOption::l_SKIP_LOADED;
3275
3276 case (char)MinimassOption::n_DUMMY:
3277 return MinimassOption::n_DUMMY;
3278
3279 default:
3280 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3281 fmt::format("Not a valid minimass option: {}, falling back to 'n' (dummy)", this->GetArgStr(index)));
3282 return MinimassOption::n_DUMMY;
3283 }
3284}
3285
3286BitMask_t Parser::GetArgCabOptions(int index)
3287{
3288 BitMask_t ret = 0;
3289 for (char c: this->GetArgStr(index))
3290 {
3291 switch (c)
3292 {
3293 case (char)CabOption::n_DUMMY: break;
3294 case (char)CabOption::c_CONTACT: ret |= Cab::OPTION_c_CONTACT ; break;
3295 case (char)CabOption::b_BUOYANT: ret |= Cab::OPTION_b_BUOYANT ; break;
3296 case (char)CabOption::p_10xTOUGHER: ret |= Cab::OPTION_p_10xTOUGHER ; break;
3297 case (char)CabOption::u_INVULNERABLE: ret |= Cab::OPTION_u_INVULNERABLE ; break;
3298 case (char)CabOption::s_BUOYANT_NO_DRAG: ret |= Cab::OPTION_s_BUOYANT_NO_DRAG ; break;
3299 case (char)CabOption::r_BUOYANT_ONLY_DRAG: ret |= Cab::OPTION_r_BUOYANT_ONLY_DRAG ; break;
3300 case (char)CabOption::D_CONTACT_BUOYANT: ret |= Cab::OPTION_D_CONTACT_BUOYANT ; break;
3301 case (char)CabOption::F_10xTOUGHER_BUOYANT: ret |= Cab::OPTION_F_10xTOUGHER_BUOYANT ; break;
3302 case (char)CabOption::S_INVULNERABLE_BUOYANT: ret |= Cab::OPTION_S_INVULNERABLE_BUOYANT; break;
3303
3304 default:
3305 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3306 fmt::format("ignoring invalid flag '{}'", c));
3307 }
3308 }
3309 return ret;
3310}
3311
3312BitMask_t Parser::GetArgTriggerOptions(int index)
3313{
3314 BitMask_t ret = 0;
3315 for (char c: this->GetArgStr(index))
3316 {
3317 switch(c)
3318 {
3319 case (char)TriggerOption::i_INVISIBLE : ret |= Trigger::OPTION_i_INVISIBLE; break;
3320 case (char)TriggerOption::c_COMMAND_STYLE : ret |= Trigger::OPTION_c_COMMAND_STYLE; break;
3321 case (char)TriggerOption::x_START_DISABLED : ret |= Trigger::OPTION_x_START_DISABLED; break;
3322 case (char)TriggerOption::b_KEY_BLOCKER : ret |= Trigger::OPTION_b_KEY_BLOCKER; break;
3323 case (char)TriggerOption::B_TRIGGER_BLOCKER : ret |= Trigger::OPTION_B_TRIGGER_BLOCKER; break;
3324 case (char)TriggerOption::A_INV_TRIGGER_BLOCKER: ret |= Trigger::OPTION_A_INV_TRIGGER_BLOCKER; break;
3325 case (char)TriggerOption::s_CMD_NUM_SWITCH : ret |= Trigger::OPTION_s_CMD_NUM_SWITCH; break;
3326 case (char)TriggerOption::h_UNLOCKS_HOOK_GROUP : ret |= Trigger::OPTION_h_UNLOCKS_HOOK_GROUP; break;
3327 case (char)TriggerOption::H_LOCKS_HOOK_GROUP : ret |= Trigger::OPTION_H_LOCKS_HOOK_GROUP; break;
3328 case (char)TriggerOption::t_CONTINUOUS : ret |= Trigger::OPTION_t_CONTINUOUS; break;
3329 case (char)TriggerOption::E_ENGINE_TRIGGER : ret |= Trigger::OPTION_E_ENGINE_TRIGGER; break;
3330
3331 default:
3332 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3333 fmt::format("ignoring invalid option '{}'", c));
3334 }
3335 }
3336 return ret;
3337}
3338
3339BitMask_t Parser::GetArgBeamOptions(int index)
3340{
3341 BitMask_t ret = 0;
3342 for (char c: this->GetArgStr(index))
3343 {
3344 switch (c)
3345 {
3346 case (char)BeamOption::i_INVISIBLE: ret |= Beam::OPTION_i_INVISIBLE; break;
3347 case (char)BeamOption::r_ROPE : ret |= Beam::OPTION_r_ROPE ; break;
3348 case (char)BeamOption::s_SUPPORT : ret |= Beam::OPTION_s_SUPPORT ; break;
3349
3350 case (char)BeamOption::v_DUMMY: break;
3351
3352 default:
3353 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3354 fmt::format("ignoring invalid option '{}'", c));
3355 }
3356 }
3357 return ret;
3358}
3359
3360BitMask_t Parser::GetArgHydroOptions (int index)
3361{
3362 BitMask_t ret = 0;
3363 for (char c: this->GetArgStr(index))
3364 {
3365 switch (c)
3366 {
3367 case (char)HydroOption::j_INVISIBLE : ret |= Hydro::OPTION_j_INVISIBLE ; break;
3368 case (char)HydroOption::s_DISABLE_ON_HIGH_SPEED : ret |= Hydro::OPTION_s_DISABLE_ON_HIGH_SPEED ; break;
3369 case (char)HydroOption::a_INPUT_AILERON : ret |= Hydro::OPTION_a_INPUT_AILERON ; break;
3370 case (char)HydroOption::r_INPUT_RUDDER : ret |= Hydro::OPTION_r_INPUT_RUDDER ; break;
3371 case (char)HydroOption::e_INPUT_ELEVATOR : ret |= Hydro::OPTION_e_INPUT_ELEVATOR ; break;
3372 case (char)HydroOption::u_INPUT_AILERON_ELEVATOR : ret |= Hydro::OPTION_u_INPUT_AILERON_ELEVATOR ; break;
3373 case (char)HydroOption::v_INPUT_InvAILERON_ELEVATOR: ret |= Hydro::OPTION_v_INPUT_InvAILERON_ELEVATOR; break;
3374 case (char)HydroOption::x_INPUT_AILERON_RUDDER : ret |= Hydro::OPTION_x_INPUT_AILERON_RUDDER ; break;
3375 case (char)HydroOption::y_INPUT_InvAILERON_RUDDER : ret |= Hydro::OPTION_y_INPUT_InvAILERON_RUDDER ; break;
3376 case (char)HydroOption::g_INPUT_ELEVATOR_RUDDER : ret |= Hydro::OPTION_g_INPUT_ELEVATOR_RUDDER ; break;
3377 case (char)HydroOption::h_INPUT_InvELEVATOR_RUDDER : ret |= Hydro::OPTION_h_INPUT_InvELEVATOR_RUDDER ; break;
3378 case (char)HydroOption::n_INPUT_NORMAL : ret |= Hydro::OPTION_n_INPUT_NORMAL ; break;
3379
3380 case (char)HydroOption::i_INVISIBLE_INPUT_NORMAL:
3381 if (ret == 0)
3382 {
3383 // Original intent: when using 'i' flag alone, also force 'n' (steering input).
3384 // For backward compatibility, do it every time 'i' comes first, even if not alone.
3385 ret |= Hydro::OPTION_n_INPUT_NORMAL;
3386 }
3387 ret |= Hydro::OPTION_j_INVISIBLE;
3388 break;
3389
3390 default:
3391 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3392 fmt::format("ignoring invalid option '{}'", c));
3393 }
3394 }
3395
3396 return ret;
3397}
3398
3399BitMask_t Parser::GetArgShockOptions(int index)
3400{
3401 BitMask_t ret = 0;
3402 for (char c: this->GetArgStr(index))
3403 {
3404 switch (c)
3405 {
3406 case (char)ShockOption::i_INVISIBLE : ret |= Shock::OPTION_i_INVISIBLE ; break;
3407 case (char)ShockOption::L_ACTIVE_LEFT : ret |= Shock::OPTION_L_ACTIVE_LEFT ; break;
3408 case (char)ShockOption::R_ACTIVE_RIGHT : ret |= Shock::OPTION_R_ACTIVE_RIGHT; break;
3409 case (char)ShockOption::m_METRIC : ret |= Shock::OPTION_m_METRIC ; break;
3410
3411 case (char)ShockOption::n_DUMMY: break;
3412 case (char)ShockOption::v_DUMMY: break;
3413
3414 default:
3415 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3416 fmt::format("ignoring invalid option '{}'", c));
3417 }
3418 }
3419 return ret;
3420}
3421
3422BitMask_t Parser::GetArgShock2Options(int index)
3423{
3424 BitMask_t ret = 0;
3425 for (char c: this->GetArgStr(index))
3426 {
3427 switch (c)
3428 {
3429 case (char)Shock2Option::i_INVISIBLE: ret |= Shock2::OPTION_i_INVISIBLE; break;
3430 case (char)Shock2Option::s_SOFT_BUMP_BOUNDS: ret |= Shock2::OPTION_s_SOFT_BUMP_BOUNDS; break;
3431 case (char)Shock2Option::m_METRIC: ret |= Shock2::OPTION_m_METRIC; break;
3432 case (char)Shock2Option::M_ABSOLUTE_METRIC: ret |= Shock2::OPTION_M_ABSOLUTE_METRIC; break;
3433
3434 case (char)Shock2Option::n_DUMMY: break;
3435 case (char)Shock2Option::v_DUMMY: break;
3436
3437 default:
3438 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3439 fmt::format("ignoring invalid option '{}'", c));
3440 }
3441 }
3442 return ret;
3443}
3444
3445BitMask_t Parser::GetArgShock3Options(int index)
3446{
3447 BitMask_t ret = 0;
3448 for (char c: this->GetArgStr(index))
3449 {
3450 switch (c)
3451 {
3452 case (char)Shock3Option::i_INVISIBLE: ret |= Shock3::OPTION_i_INVISIBLE; break;
3453 case (char)Shock3Option::m_METRIC: ret |= Shock3::OPTION_m_METRIC; break;
3454 case (char)Shock3Option::M_ABSOLUTE_METRIC: ret |= Shock3::OPTION_M_ABSOLUTE_METRIC; break;
3455
3456 case (char)Shock3Option::n_DUMMY: break;
3457 case (char)Shock3Option::v_DUMMY: break;
3458
3459 default:
3460 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3461 fmt::format("ignoring invalid option '{}'", c));
3462 }
3463 }
3464 return ret;
3465}
3466
3467BitMask_t Parser::GetArgNodeOptions(int index)
3468{
3469 BitMask_t ret = 0;
3470 for (char c: this->GetArgStr(index))
3471 {
3472 switch (c)
3473 {
3474 case (char)NodeOption::m_NO_MOUSE_GRAB : ret |= Node::OPTION_m_NO_MOUSE_GRAB ; break;
3475 case (char)NodeOption::f_NO_SPARKS : ret |= Node::OPTION_f_NO_SPARKS ; break;
3476 case (char)NodeOption::x_EXHAUST_POINT : ret |= Node::OPTION_x_EXHAUST_POINT ; break;
3477 case (char)NodeOption::y_EXHAUST_DIRECTION : ret |= Node::OPTION_y_EXHAUST_DIRECTION ; break;
3478 case (char)NodeOption::c_NO_GROUND_CONTACT : ret |= Node::OPTION_c_NO_GROUND_CONTACT ; break;
3479 case (char)NodeOption::h_HOOK_POINT : ret |= Node::OPTION_h_HOOK_POINT ; break;
3480 case (char)NodeOption::e_TERRAIN_EDIT_POINT: ret |= Node::OPTION_e_TERRAIN_EDIT_POINT; break;
3481 case (char)NodeOption::b_EXTRA_BUOYANCY : ret |= Node::OPTION_b_EXTRA_BUOYANCY ; break;
3482 case (char)NodeOption::p_NO_PARTICLES : ret |= Node::OPTION_p_NO_PARTICLES ; break;
3483 case (char)NodeOption::L_LOG : ret |= Node::OPTION_L_LOG ; break;
3484 case (char)NodeOption::l_LOAD_WEIGHT : ret |= Node::OPTION_l_LOAD_WEIGHT ; break;
3485
3486 case (char)NodeOption::n_DUMMY: break;
3487
3488 default:
3489 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3490 fmt::format("ignoring invalid option '{}'", c));
3491 }
3492 }
3493 return ret;
3494}
3495
3496SpecialProp Parser::IdentifySpecialProp(const std::string& str)
3497{
3498 if (str.find("leftmirror" ) != std::string::npos) { return SpecialProp::MIRROR_LEFT; }
3499 if (str.find("rightmirror" ) != std::string::npos) { return SpecialProp::MIRROR_RIGHT; }
3500 if (str.find("dashboard-rh") != std::string::npos) { return SpecialProp::DASHBOARD_RIGHT; }
3501 if (str.find("dashboard" ) != std::string::npos) { return SpecialProp::DASHBOARD_LEFT; }
3502 if (Ogre::StringUtil::startsWith(str, "spinprop", false) ) { return SpecialProp::AERO_PROP_SPIN; }
3503 if (Ogre::StringUtil::startsWith(str, "pale", false) ) { return SpecialProp::AERO_PROP_BLADE; }
3504 if (Ogre::StringUtil::startsWith(str, "seat", false) ) { return SpecialProp::DRIVER_SEAT; }
3505 if (Ogre::StringUtil::startsWith(str, "seat2", false) ) { return SpecialProp::DRIVER_SEAT_2; }
3506 if (Ogre::StringUtil::startsWith(str, "beacon", false) ) { return SpecialProp::BEACON; }
3507 if (Ogre::StringUtil::startsWith(str, "redbeacon", false)) { return SpecialProp::REDBEACON; }
3508 if (Ogre::StringUtil::startsWith(str, "lightb", false) ) { return SpecialProp::LIGHTBAR; }
3509 return SpecialProp::NONE;
3510}
3511
3512int Parser::GetArgDashboardInputDataType(int index)
3513{
3514 std::string str = this->GetArgStr(index);
3515 if (str == "bool") return DC_BOOL;
3516 if (str == "int") return DC_INT;
3517 if (str == "float") return DC_FLOAT;
3518 if (str == "string") return DC_CHAR;
3519
3520 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3521 fmt::format("Not a valid dashboard input data type: '{}'", str));
3522 return DC_INVALID;
3523}
3524
3525EngineType Parser::GetArgEngineType(int index)
3526{
3527 char c = this->GetArgChar(index);
3528 switch (c)
3529 {
3530 case (char)EngineType::t_TRUCK:
3531 case (char)EngineType::c_CAR:
3532 case (char)EngineType::e_ECAR:
3533 return EngineType(c);
3534
3535 default:
3536 fmt::format("invalid EngineType '{}', falling back to 't' (truck)", c);
3537 return EngineType::t_TRUCK;
3538 }
3539}
3540
3541ManagedMaterialType Parser::GetArgManagedMatType(int index)
3542{
3543 std::string str = this->GetArgStr(index);
3544 if (str == "mesh_standard") return ManagedMaterialType::MESH_STANDARD;
3545 if (str == "mesh_transparent") return ManagedMaterialType::MESH_TRANSPARENT;
3546 if (str == "flexmesh_standard") return ManagedMaterialType::FLEXMESH_STANDARD;
3547 if (str == "flexmesh_transparent") return ManagedMaterialType::FLEXMESH_TRANSPARENT;
3548
3549 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3550 fmt::format("Not a valid ManagedMaterialType: '{}'", str));
3551 return ManagedMaterialType::INVALID;
3552}
3553
3554VideoCamRole Parser::GetArgVideoCamRole(int index)
3555{
3556 int role = this->GetArgInt(index);
3557 switch (role)
3558 {
3559 case VCAM_ROLE_VIDEOCAM: return VCAM_ROLE_VIDEOCAM;
3560 case VCAM_ROLE_TRACKING_VIDEOCAM: return VCAM_ROLE_TRACKING_VIDEOCAM;
3561 case VCAM_ROLE_MIRROR: return VCAM_ROLE_MIRROR;
3562 case VCAM_ROLE_MIRROR_NOFLIP: return VCAM_ROLE_MIRROR_NOFLIP;
3563 default:
3564 this->LogMessage(Console::CONSOLE_SYSTEM_WARNING,
3565 fmt::format("Invalid value of 'camera role' ({}), videocamera will not work", role));
3566 return VCAM_ROLE_INVALID;
3567 }
3568}
3569
3570int Parser::TokenizeCurrentLine()
3571{
3572 int cur_arg = 0;
3573 const char* cur_char = m_current_line;
3574 int arg_len = 0;
3575 while ((*cur_char != '\0') && (cur_arg < Parser::LINE_MAX_ARGS))
3576 {
3577 const bool is_arg = !IsSeparator(*cur_char);
3578 if ((arg_len == 0) && is_arg)
3579 {
3580 m_args[cur_arg].start = cur_char;
3581 arg_len = 1;
3582 }
3583 else if ((arg_len > 0) && !is_arg)
3584 {
3585 m_args[cur_arg].length = arg_len;
3586 arg_len = 0;
3587 ++cur_arg;
3588 }
3589 else if (is_arg)
3590 {
3591 ++arg_len;
3592 }
3593 ++cur_char;
3594 }
3595 if (arg_len > 0)
3596 {
3597 m_args[cur_arg].length = arg_len;
3598 ++cur_arg;
3599 }
3600
3601 m_num_args = cur_arg;
3602 return cur_arg;
3603}
3604
3605void Parser::ProcessOgreStream(Ogre::DataStream* stream, Ogre::String resource_group)
3606{
3607 m_resource_group = resource_group;
3608 m_filename = stream->getName();
3609
3610 char raw_line_buf[LINE_BUFFER_LENGTH];
3611 while (!stream->eof())
3612 {
3613 try
3614 {
3615 stream->readLine(raw_line_buf, LINE_BUFFER_LENGTH - 1); // Ensure we don't overflow
3616 raw_line_buf[LINE_BUFFER_LENGTH - 1] = '\0'; // Null-terminate the buffer
3617 }
3618 catch (Ogre::Exception &ex)
3619 {
3620 App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_ACTOR, Console::CONSOLE_SYSTEM_ERROR,
3621 fmt::format("Could not read truck file: {}", ex.getFullDescription()));
3622 break;
3623 }
3624
3625 this->ProcessRawLine(raw_line_buf);
3626 }
3627}
3628
3629void Parser::ProcessRawLine(const char* raw_line_buf)
3630{
3631 const char* raw_start = raw_line_buf;
3632 const char* raw_end = raw_line_buf + strnlen(raw_line_buf, LINE_BUFFER_LENGTH);
3633
3634 // Trim leading whitespace
3635 while (IsWhitespace(*raw_start) && (raw_start != raw_end))
3636 {
3637 ++raw_start;
3638 }
3639
3640 // Skip empty lines
3641 if (raw_start == raw_end)
3642 {
3643 ++m_current_line_number;
3644 return;
3645 }
3646
3647 // Record comment lines
3648 if ((*raw_start == ';') || (*raw_start == '/'))
3649 {
3650 m_pending_doc_comment.comment_text += raw_line_buf;
3651 m_pending_doc_comment.comment_text += '\n';
3652 ++m_current_line_number;
3653 return;
3654 }
3655
3656 // Sanitize UTF-8
3657 memset(m_current_line, 0, LINE_BUFFER_LENGTH);
3658 char* out_start = m_current_line;
3659 utf8::replace_invalid(raw_start, raw_end, out_start, '?');
3660
3661 // Process
3662 this->ProcessCurrentLine();
3663 ++m_current_line_number;
3664}
3665
3666} // namespace RigDef
Application.h
Central state/object manager and communications hub.
PARSEINT
#define PARSEINT(x)
Definition Application.h:58
LOG
void LOG(const char *msg)
Legacy alias - formerly a macro.
Definition Application.h:897
keyword
static int keyword
Definition Bench_TruckParser_IdentifyKeyword.cpp:1448
BITMASK_IS_1
#define BITMASK_IS_1(VAR, FLAGS)
Definition BitFlags.h:14
BITMASK_SET_1
#define BITMASK_SET_1(VAR, FLAGS)
Definition BitFlags.h:17
BitMask_t
uint32_t BitMask_t
Definition BitFlags.h:7
CacheSystem.h
A database of user-installed content alias 'mods' (vehicles, terrains...)
strnlen
#define strnlen(str, len)
Definition InputEngine.cpp:400
RigDef_File.h
Data structures representing 'truck' file format, see https://docs.rigsofrods.org/vehicle-creation/fi...
RigDef_Parser.h
Checks the rig-def file syntax and loads data to memory.
RigDef_Regexes.h
Defines regular expressions to verify and pull data from rig-def file. 'E' stands for Expression.
RigDef::Node::Id::SetNum
void SetNum(unsigned int id_num)
Definition RigDef_Node.cpp:55
RigDef::Node::Id::setStr
void setStr(std::string const &id_str)
Definition RigDef_Node.cpp:63
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::Parser::m_current_line
char m_current_line[LINE_BUFFER_LENGTH]
Definition RigDef_Parser.h:277
RigDef::Parser::ParseArgInt
int ParseArgInt(const char *str)
Definition RigDef_Parser.cpp:3224
RigDef::Parser::GetArgBool
bool GetArgBool(int index)
Definition RigDef_Parser.cpp:3229
RigDef::Parser::GetArgBeamOptions
BitMask_t GetArgBeamOptions(int index)
Definition RigDef_Parser.cpp:3339
RigDef::Parser::m_definition
RigDef::DocumentPtr m_definition
Definition RigDef_Parser.h:292
RigDef::Parser::m_set_default_minimass
std::shared_ptr< DefaultMinimass > m_set_default_minimass
Definition RigDef_Parser.h:268
RigDef::Parser::ParseTractionControl
void ParseTractionControl()
Definition RigDef_Parser.cpp:453
RigDef::Parser::m_resource_group
Ogre::String m_resource_group
Definition RigDef_Parser.h:290
RigDef::Parser::ParseDirectiveSetDefaultMinimass
void ParseDirectiveSetDefaultMinimass()
Definition RigDef_Parser.cpp:2198
RigDef::Parser::m_ror_node_defaults
std::shared_ptr< NodeDefaults > m_ror_node_defaults
Definition RigDef_Parser.h:261
RigDef::Parser::ParseMaterialFlareBindings
void ParseMaterialFlareBindings()
Definition RigDef_Parser.cpp:2606
RigDef::Parser::GetArgShock3Options
BitMask_t GetArgShock3Options(int index)
Definition RigDef_Parser.cpp:3445
RigDef::Parser::LINE_MAX_ARGS
static const int LINE_MAX_ARGS
Definition RigDef_Parser.h:62
RigDef::Parser::GetArgWingSurface
WingControlSurface GetArgWingSurface(int index)
Definition RigDef_Parser.cpp:3234
RigDef::Parser::m_ror_default_inertia
std::shared_ptr< Inertia > m_ror_default_inertia
Definition RigDef_Parser.h:260
RigDef::Parser::GetArgVideoCamRole
RoR::VideoCamRole GetArgVideoCamRole(int index)
Definition RigDef_Parser.cpp:3554
RigDef::Parser::GetArgRigidityNode
Node::Ref GetArgRigidityNode(int index)
Definition RigDef_Parser.cpp:3086
RigDef::Parser::GetArgBraking
RoR::WheelBraking GetArgBraking(int index)
Definition RigDef_Parser.cpp:3113
RigDef::Parser::_ParseNodeRef
Node::Ref _ParseNodeRef(std::string const &node_id_str)
Definition RigDef_Parser.cpp:2171
RigDef::Parser::ParseCustomDashboardInputs
void ParseCustomDashboardInputs()
Definition RigDef_Parser.cpp:1504
RigDef::Parser::ParseDirectiveSetInertiaDefaults
void ParseDirectiveSetInertiaDefaults()
Definition RigDef_Parser.cpp:2231
RigDef::Parser::GetArgShockOptions
BitMask_t GetArgShockOptions(int index)
Definition RigDef_Parser.cpp:3399
RigDef::Parser::m_args
Token m_args[LINE_MAX_ARGS]
Tokens of current line.
Definition RigDef_Parser.h:278
RigDef::Parser::m_root_module
std::shared_ptr< Document::Module > m_root_module
Definition RigDef_Parser.h:273
RigDef::Parser::m_current_submesh
std::shared_ptr< Submesh > m_current_submesh
Parser state.
Definition RigDef_Parser.h:283
RigDef::Parser::ParseDirectiveForvert
void ParseDirectiveForvert()
Definition RigDef_Parser.cpp:930
RigDef::Parser::ParseDirectivePropCameraMode
void ParseDirectivePropCameraMode()
Definition RigDef_Parser.cpp:630
RigDef::Parser::GetArgNodeRef
Node::Ref GetArgNodeRef(int index)
Definition RigDef_Parser.cpp:3132
RigDef::Parser::GetArgMinimassOption
MinimassOption GetArgMinimassOption(int index)
Definition RigDef_Parser.cpp:3269
RigDef::Parser::BeginBlock
void BeginBlock(RigDef::Keyword keyword)
Definition RigDef_Parser.cpp:2914
RigDef::Parser::LINE_BUFFER_LENGTH
static const int LINE_BUFFER_LENGTH
Definition RigDef_Parser.h:61
RigDef::Parser::ParseDirectiveSetManagedMaterialsOptions
void ParseDirectiveSetManagedMaterialsOptions()
Definition RigDef_Parser.cpp:573
RigDef::Parser::GetArgFlareType
RoR::FlareType GetArgFlareType(int index)
Definition RigDef_Parser.cpp:3151
RigDef::Parser::m_any_named_node_defined
bool m_any_named_node_defined
Parser state.
Definition RigDef_Parser.h:282
RigDef::Parser::ProcessForsetLine
static void ProcessForsetLine(RigDef::Flexbody &def, const std::string &line, int line_number=-1)
Definition RigDef_Parser.cpp:983
RigDef::Parser::GetArgStr
std::string GetArgStr(int index)
Definition RigDef_Parser.cpp:3030
RigDef::Parser::GetArgInt
int GetArgInt(int index)
Definition RigDef_Parser.cpp:3081
RigDef::Parser::GetArgDashboardInputDataType
int GetArgDashboardInputDataType(int index)
Definition RigDef_Parser.cpp:3512
RigDef::Parser::m_log_keyword
Keyword m_log_keyword
Definition RigDef_Parser.h:281
RigDef::Parser::ParseDirectiveSetBeamDefaultsScale
void ParseDirectiveSetBeamDefaultsScale()
Definition RigDef_Parser.cpp:581
RigDef::Parser::m_current_line_number
unsigned int m_current_line_number
Definition RigDef_Parser.h:276
RigDef::Parser::GetArgUint
unsigned GetArgUint(int index)
Definition RigDef_Parser.cpp:3146
RigDef::Parser::ParseDirectiveDefaultSkin
void ParseDirectiveDefaultSkin()
Definition RigDef_Parser.cpp:1146
RigDef::Parser::GetArgWheelSide
RoR::WheelSide GetArgWheelSide(int index)
Definition RigDef_Parser.cpp:3040
RigDef::Parser::GetArgManagedMatType
ManagedMaterialType GetArgManagedMatType(int index)
Definition RigDef_Parser.cpp:3541
RigDef::Parser::ParseDirectiveSubmesh
void ParseDirectiveSubmesh()
Definition RigDef_Parser.cpp:644
RigDef::Parser::m_current_managed_material_options
ManagedMaterialsOptions m_current_managed_material_options
Definition RigDef_Parser.h:270
RigDef::Parser::ParseDirectiveBackmesh
void ParseDirectiveBackmesh()
Definition RigDef_Parser.cpp:650
RigDef::Parser::GetArgEngineType
EngineType GetArgEngineType(int index)
Definition RigDef_Parser.cpp:3525
RigDef::Parser::GetArgNodeOptions
BitMask_t GetArgNodeOptions(int index)
Definition RigDef_Parser.cpp:3467
RigDef::Parser::IdentifySpecialProp
static SpecialProp IdentifySpecialProp(const std::string &str)
Definition RigDef_Parser.cpp:3496
RigDef::Parser::GetArgLong
long GetArgLong(int index)
Definition RigDef_Parser.cpp:3056
RigDef::Parser::CheckNumArguments
bool CheckNumArguments(int num_required_args)
Definition RigDef_Parser.cpp:327
RigDef::Parser::ParseSetSkeletonSettings
void ParseSetSkeletonSettings()
Definition RigDef_Parser.cpp:536
RigDef::Parser::_ParseBaseMeshWheel
void _ParseBaseMeshWheel(BaseMeshWheel &mesh_wheel)
Definition RigDef_Parser.cpp:680
RigDef::Parser::ProcessGlobalDirective
void ProcessGlobalDirective(Keyword keyword)
Directives that should only appear in root module.
Definition RigDef_Parser.cpp:662
RigDef::Parser::GetArgManagedTex
std::string GetArgManagedTex(int index)
Definition RigDef_Parser.cpp:3263
RigDef::Parser::ParseArgFloat
float ParseArgFloat(const char *str)
Definition RigDef_Parser.cpp:3196
RigDef::Parser::m_current_module
std::shared_ptr< Document::Module > m_current_module
Definition RigDef_Parser.h:274
RigDef::Parser::LogMessage
void LogMessage(RoR::Console::MessageType type, std::string const &msg)
Adds a message to console.
Definition RigDef_Parser.cpp:2859
RigDef::Parser::ProcessCurrentLine
void ProcessCurrentLine()
Definition RigDef_Parser.cpp:77
RigDef::Parser::m_current_camera_rail
std::shared_ptr< CameraRail > m_current_camera_rail
Parser state.
Definition RigDef_Parser.h:284
RigDef::Parser::m_user_beam_defaults
std::shared_ptr< BeamDefaults > m_user_beam_defaults
Definition RigDef_Parser.h:266
RigDef::Parser::ParseDirectiveAddAnimation
void ParseDirectiveAddAnimation()
Definition RigDef_Parser.cpp:1189
RigDef::Parser::ParseFileFormatVersion
void ParseFileFormatVersion()
Definition RigDef_Parser.cpp:1135
RigDef::Parser::ParseDirectiveSectionConfig
void ParseDirectiveSectionConfig()
Definition RigDef_Parser.cpp:3015
RigDef::Parser::m_filename
Ogre::String m_filename
Definition RigDef_Parser.h:289
RigDef::Parser::GetArgPropulsion
RoR::WheelPropulsion GetArgPropulsion(int index)
Definition RigDef_Parser.cpp:3096
RigDef::Parser::m_sequential_importer
SequentialImporter m_sequential_importer
Definition RigDef_Parser.h:287
RigDef::Parser::GetArgCabOptions
BitMask_t GetArgCabOptions(int index)
Definition RigDef_Parser.cpp:3286
RigDef::Parser::m_current_block
Keyword m_current_block
Definition RigDef_Parser.h:280
RigDef::Parser::IdentifyKeyword
static Keyword IdentifyKeyword(const std::string &line)
Definition RigDef_Parser.cpp:2868
RigDef::Parser::m_user_node_defaults
std::shared_ptr< NodeDefaults > m_user_node_defaults
Definition RigDef_Parser.h:267
RigDef::Parser::m_num_args
int m_num_args
Number of tokens on current line.
Definition RigDef_Parser.h:279
RigDef::Parser::ParseFlaregroupsNoImport
void ParseFlaregroupsNoImport()
Definition RigDef_Parser.cpp:2206
RigDef::Parser::m_user_default_inertia
std::shared_ptr< Inertia > m_user_default_inertia
Definition RigDef_Parser.h:265
RigDef::Parser::ParseDirectiveFlexbodyCameraMode
void ParseDirectiveFlexbodyCameraMode()
Definition RigDef_Parser.cpp:846
RigDef::Parser::_TrimTrailingComments
static void _TrimTrailingComments(std::string const &line_in, std::string &line_out)
Definition RigDef_Parser.cpp:2472
RigDef::Parser::ParseDirectiveSetBeamDefaults
void ParseDirectiveSetBeamDefaults()
Definition RigDef_Parser.cpp:595
RigDef::Parser::ParseOptionalInertia
void ParseOptionalInertia(Inertia &inertia, int index)
Definition RigDef_Parser.cpp:2692
RigDef::Parser::ParseSubmeshGroundModel
void ParseSubmeshGroundModel()
Definition RigDef_Parser.cpp:516
RigDef::Parser::GetArgExtCameraMode
RoR::ExtCameraMode GetArgExtCameraMode(int index)
Definition RigDef_Parser.cpp:3179
RigDef::Parser::ProcessRawLine
void ProcessRawLine(const char *line)
Definition RigDef_Parser.cpp:3629
RigDef::Parser::GetArgChar
char GetArgChar(int index)
Definition RigDef_Parser.cpp:3035
RigDef::Parser::GetArgTriggerOptions
BitMask_t GetArgTriggerOptions(int index)
Definition RigDef_Parser.cpp:3312
RigDef::Parser::ParseSetCollisionRange
void ParseSetCollisionRange()
Definition RigDef_Parser.cpp:362
RigDef::Parser::m_pending_doc_comment
DocComment m_pending_doc_comment
To be linked with the following element.
Definition RigDef_Parser.h:285
RigDef::Parser::ParseArgUint
unsigned ParseArgUint(const char *str)
Definition RigDef_Parser.cpp:3206
RigDef::Parser::GetArgHydroOptions
BitMask_t GetArgHydroOptions(int index)
Definition RigDef_Parser.cpp:3360
RigDef::Parser::GetArgShock2Options
BitMask_t GetArgShock2Options(int index)
Definition RigDef_Parser.cpp:3422
RigDef::Parser::ProcessChangeModuleLine
void ProcessChangeModuleLine(Keyword keyword)
Definition RigDef_Parser.cpp:2947
RigDef::Parser::ParseTurbopropsUnified
void ParseTurbopropsUnified()
Definition RigDef_Parser.cpp:1837
RigDef::Parser::GetArgFloat
float GetArgFloat(int index)
Definition RigDef_Parser.cpp:3191
RigDef::Parser::ProcessOgreStream
void ProcessOgreStream(Ogre::DataStream *stream, Ogre::String resource_group)
Definition RigDef_Parser.cpp:3605
RigDef::Parser::ParseDirectiveForset
void ParseDirectiveForset()
Definition RigDef_Parser.cpp:919
RigDef::Parser::FlushPendingDocComment
void FlushPendingDocComment(size_t vectorlen, RigDef::Keyword keyword)
Definition RigDef_Parser.cpp:2996
RigDef::Parser::ParseDirectiveSetNodeDefaults
void ParseDirectiveSetNodeDefaults()
Definition RigDef_Parser.cpp:554
RigDef::Parser::ParseDirectiveDetacherGroup
void ParseDirectiveDetacherGroup()
Definition RigDef_Parser.cpp:1158
RigDef::Parser::_ParseDifferentialTypes
void _ParseDifferentialTypes(DifferentialTypeVec &diff_types, std::string const &options_str)
Definition RigDef_Parser.cpp:2700
RigDef::Parser::GetArgNullableNode
Node::Ref GetArgNullableNode(int index)
Definition RigDef_Parser.cpp:3137
RigDef::SequentialImporter::AddNamedNode
bool AddNamedNode(std::string const &name)
Definition RigDef_SequentialImporter.cpp:735
RigDef::SequentialImporter::AddGeneratedNode
void AddGeneratedNode(Keyword generated_from, NodeMapEntry::OriginDetail detail=NodeMapEntry::DETAIL_UNDEFINED)
Definition RigDef_SequentialImporter.cpp:751
RigDef::SequentialImporter::Process
void Process(RigDef::DocumentPtr def)
Traverse whole rig definition and resolve all node references.
Definition RigDef_SequentialImporter.cpp:85
RigDef::SequentialImporter::GenerateNodesForWheel
void GenerateNodesForWheel(Keyword generated_from, int num_rays, bool has_rigidity_node)
Definition RigDef_SequentialImporter.cpp:54
RigDef::SequentialImporter::AddNumberedNode
bool AddNumberedNode(unsigned int number)
Definition RigDef_SequentialImporter.cpp:721
RoR::Console::CONSOLE_MSGTYPE_ACTOR
@ CONSOLE_MSGTYPE_ACTOR
Parsing/spawn/simulation messages for actors.
Definition Console.h:63
RoR::Console::putMessage
void putMessage(MessageArea area, MessageType type, std::string const &msg, std::string icon="")
Definition Console.cpp:103
RoR::Console::CONSOLE_SYSTEM_ERROR
@ CONSOLE_SYSTEM_ERROR
Definition Console.h:52
RoR::Console::CONSOLE_SYSTEM_WARNING
@ CONSOLE_SYSTEM_WARNING
Definition Console.h:53
RigDef::Keyword
Keyword
Definition Application.h:180
RigDef::KeywordToString
const char * KeywordToString(RigDef::Keyword keyword)
Definition Application.cpp:711
RigDef::Keyword::COMMANDS2
@ COMMANDS2
RigDef::Keyword::FLARES
@ FLARES
RigDef::Keyword::TURBOPROPS2
@ TURBOPROPS2
RigDef::Keyword::VIDEOCAMERA
@ VIDEOCAMERA
RigDef::Keyword::FLAREGROUPS_NO_IMPORT
@ FLAREGROUPS_NO_IMPORT
RigDef::Keyword::FLEXBODIES
@ FLEXBODIES
RigDef::Keyword::SLIDENODE_CONNECT_INSTANTLY
@ SLIDENODE_CONNECT_INSTANTLY
RigDef::Keyword::CRUISECONTROL
@ CRUISECONTROL
RigDef::Keyword::ADD_ANIMATION
@ ADD_ANIMATION
RigDef::Keyword::SHOCKS
@ SHOCKS
RigDef::Keyword::ENGINE
@ ENGINE
RigDef::Keyword::DETACHER_GROUP
@ DETACHER_GROUP
RigDef::Keyword::BACKMESH
@ BACKMESH
RigDef::Keyword::FLARES3
@ FLARES3
RigDef::Keyword::MESHWHEELS2
@ MESHWHEELS2
RigDef::Keyword::WINGS
@ WINGS
RigDef::Keyword::DEFAULT_SKIN
@ DEFAULT_SKIN
RigDef::Keyword::TIES
@ TIES
RigDef::Keyword::CAMERAS
@ CAMERAS
RigDef::Keyword::SCRIPTS
@ SCRIPTS
RigDef::Keyword::SET_DEFAULT_MINIMASS
@ SET_DEFAULT_MINIMASS
RigDef::Keyword::SET_BEAM_DEFAULTS_SCALE
@ SET_BEAM_DEFAULTS_SCALE
RigDef::Keyword::DESCRIPTION
@ DESCRIPTION
RigDef::Keyword::GUISETTINGS
@ GUISETTINGS
RigDef::Keyword::END_DESCRIPTION
@ END_DESCRIPTION
RigDef::Keyword::PROP_CAMERA_MODE
@ PROP_CAMERA_MODE
RigDef::Keyword::TEXCOORDS
@ TEXCOORDS
RigDef::Keyword::SCREWPROPS
@ SCREWPROPS
RigDef::Keyword::SECTION
@ SECTION
RigDef::Keyword::SET_INERTIA_DEFAULTS
@ SET_INERTIA_DEFAULTS
RigDef::Keyword::GLOBALS
@ GLOBALS
RigDef::Keyword::TORQUECURVE
@ TORQUECURVE
RigDef::Keyword::ROTATORS
@ ROTATORS
RigDef::Keyword::SET_BEAM_DEFAULTS
@ SET_BEAM_DEFAULTS
RigDef::Keyword::AIRBRAKES
@ AIRBRAKES
RigDef::Keyword::TRACTIONCONTROL
@ TRACTIONCONTROL
RigDef::Keyword::SET_COLLISION_RANGE
@ SET_COLLISION_RANGE
RigDef::Keyword::HELP
@ HELP
RigDef::Keyword::PROPS
@ PROPS
RigDef::Keyword::ROPABLES
@ ROPABLES
RigDef::Keyword::ASSETPACKS
@ ASSETPACKS
RigDef::Keyword::EXTCAMERA
@ EXTCAMERA
RigDef::Keyword::ANIMATORS
@ ANIMATORS
RigDef::Keyword::SUBMESH_GROUNDMODEL
@ SUBMESH_GROUNDMODEL
RigDef::Keyword::AUTHOR
@ AUTHOR
RigDef::Keyword::SUBMESH
@ SUBMESH
RigDef::Keyword::ANTILOCKBRAKES
@ ANTILOCKBRAKES
RigDef::Keyword::WHEELS
@ WHEELS
RigDef::Keyword::NODECOLLISION
@ NODECOLLISION
RigDef::Keyword::CUSTOMDASHBOARDINPUTS
@ CUSTOMDASHBOARDINPUTS
RigDef::Keyword::SOUNDSOURCES
@ SOUNDSOURCES
RigDef::Keyword::SHOCKS2
@ SHOCKS2
RigDef::Keyword::GUID
@ GUID
RigDef::Keyword::FORSET
@ FORSET
RigDef::Keyword::TURBOJETS
@ TURBOJETS
RigDef::Keyword::SOUNDSOURCES2
@ SOUNDSOURCES2
RigDef::Keyword::RIGIDIFIERS
@ RIGIDIFIERS
RigDef::Keyword::FLARES2
@ FLARES2
RigDef::Keyword::ENABLE_ADVANCED_DEFORMATION
@ ENABLE_ADVANCED_DEFORMATION
RigDef::Keyword::DISABLEDEFAULTSOUNDS
@ DISABLEDEFAULTSOUNDS
RigDef::Keyword::EXHAUSTS
@ EXHAUSTS
RigDef::Keyword::FIXES
@ FIXES
RigDef::Keyword::BRAKES
@ BRAKES
RigDef::Keyword::AXLES
@ AXLES
RigDef::Keyword::NODES
@ NODES
RigDef::Keyword::SET_MANAGEDMATERIALS_OPTIONS
@ SET_MANAGEDMATERIALS_OPTIONS
RigDef::Keyword::ENVMAP
@ ENVMAP
RigDef::Keyword::IMPORTCOMMANDS
@ IMPORTCOMMANDS
RigDef::Keyword::TRIGGERS
@ TRIGGERS
RigDef::Keyword::INTERAXLES
@ INTERAXLES
RigDef::Keyword::TURBOPROPS
@ TURBOPROPS
RigDef::Keyword::HOOKS
@ HOOKS
RigDef::Keyword::NODES2
@ NODES2
RigDef::Keyword::FORWARDCOMMANDS
@ FORWARDCOMMANDS
RigDef::Keyword::FILEFORMATVERSION
@ FILEFORMATVERSION
RigDef::Keyword::FILEINFO
@ FILEINFO
RigDef::Keyword::CAMERARAIL
@ CAMERARAIL
RigDef::Keyword::COMMANDS
@ COMMANDS
RigDef::Keyword::PISTONPROPS
@ PISTONPROPS
RigDef::Keyword::HIDEINCHOOSER
@ HIDEINCHOOSER
RigDef::Keyword::RAILGROUPS
@ RAILGROUPS
RigDef::Keyword::ENGTURBO
@ ENGTURBO
RigDef::Keyword::CAB
@ CAB
RigDef::Keyword::ENGOPTION
@ ENGOPTION
RigDef::Keyword::SLIDENODES
@ SLIDENODES
RigDef::Keyword::ROLLON
@ ROLLON
RigDef::Keyword::END
@ END
RigDef::Keyword::MANAGEDMATERIALS
@ MANAGEDMATERIALS
RigDef::Keyword::FORVERT
@ FORVERT
RigDef::Keyword::END_SECTION
@ END_SECTION
RigDef::Keyword::FLEXBODYWHEELS
@ FLEXBODYWHEELS
RigDef::Keyword::MINIMASS
@ MINIMASS
RigDef::Keyword::SHOCKS3
@ SHOCKS3
RigDef::Keyword::END_COMMENT
@ END_COMMENT
RigDef::Keyword::MESHWHEELS
@ MESHWHEELS
RigDef::Keyword::FLEXBODY_CAMERA_MODE
@ FLEXBODY_CAMERA_MODE
RigDef::Keyword::ROTATORS2
@ ROTATORS2
RigDef::Keyword::CINECAM
@ CINECAM
RigDef::Keyword::FUSEDRAG
@ FUSEDRAG
RigDef::Keyword::INVALID
@ INVALID
RigDef::Keyword::CONTACTERS
@ CONTACTERS
RigDef::Keyword::SPEEDLIMITER
@ SPEEDLIMITER
RigDef::Keyword::WHEELS2
@ WHEELS2
RigDef::Keyword::TRANSFERCASE
@ TRANSFERCASE
RigDef::Keyword::RESCUER
@ RESCUER
RigDef::Keyword::MATERIALFLAREBINDINGS
@ MATERIALFLAREBINDINGS
RigDef::Keyword::BEAMS
@ BEAMS
RigDef::Keyword::HYDROS
@ HYDROS
RigDef::Keyword::SET_NODE_DEFAULTS
@ SET_NODE_DEFAULTS
RigDef::Keyword::WHEELDETACHERS
@ WHEELDETACHERS
RigDef::Keyword::ROPES
@ ROPES
RigDef::Keyword::SET_SKELETON_SETTINGS
@ SET_SKELETON_SETTINGS
RigDef::Keyword::COMMENT
@ COMMENT
RigDef::Keyword::HOOKGROUP
@ HOOKGROUP
RigDef::Keyword::COLLISIONBOXES
@ COLLISIONBOXES
RigDef::Keyword::LOCKGROUPS
@ LOCKGROUPS
RigDef::Keyword::PARTICLES
@ PARTICLES
RigDef::Keyword::LOCKGROUP_DEFAULT_NOLOCK
@ LOCKGROUP_DEFAULT_NOLOCK
BEAM_SKELETON_DIAMETER
static const float BEAM_SKELETON_DIAMETER
Definition SimConstants.h:57
DEFAULT_SPRING
static const float DEFAULT_SPRING
Definition SimConstants.h:48
DEFAULT_BEAM_DIAMETER
static const float DEFAULT_BEAM_DIAMETER
5 centimeters default beam width
Definition SimConstants.h:52
BEAM_DEFORM
static const float BEAM_DEFORM
Definition SimConstants.h:61
DEFAULT_DAMP
static const float DEFAULT_DAMP
Definition SimConstants.h:49
BEAM_PLASTIC_COEF_DEFAULT
static const float BEAM_PLASTIC_COEF_DEFAULT
Definition SimConstants.h:63
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::Shock3Option::M_ABSOLUTE_METRIC
@ M_ABSOLUTE_METRIC
Absolute metric values for shortbound/longbound, settings apply without regarding to the original len...
RigDef::Shock3Option::m_METRIC
@ m_METRIC
metric values for shortbound/longbound applying to the length of the beam.
RigDef::IsSeparator
bool IsSeparator(char c)
Definition RigDef_Parser.cpp:55
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::ManagedMaterialType
ManagedMaterialType
Definition RigDef_File.h:79
RigDef::DifferentialType
DifferentialType
Definition RigDef_File.h:98
RigDef::WingControlSurface
WingControlSurface
Definition RigDef_File.h:114
RigDef::DifferentialTypeVec
std::vector< DifferentialType > DifferentialTypeVec
Definition RigDef_File.h:105
RigDef::MinimassOption::l_SKIP_LOADED
@ l_SKIP_LOADED
Only apply minimum mass to nodes without "L" option.
RigDef::DocumentPtr
std::shared_ptr< Document > DocumentPtr
Definition ForwardDeclarations.h:293
RigDef::IsWhitespace
bool IsWhitespace(char c)
Definition RigDef_Parser.cpp:50
RigDef::Shock2Option::s_SOFT_BUMP_BOUNDS
@ s_SOFT_BUMP_BOUNDS
soft bump boundaries, use when shocks reach limiters too often and "jumprebound" (default is hard bum...
RigDef::Shock2Option::M_ABSOLUTE_METRIC
@ M_ABSOLUTE_METRIC
Absolute metric values for shortbound/longbound, settings apply without regarding to the original len...
RigDef::Shock2Option::m_METRIC
@ m_METRIC
metric values for shortbound/longbound applying to the length of the beam.
RigDef::HydroOption::i_INVISIBLE_INPUT_NORMAL
@ i_INVISIBLE_INPUT_NORMAL
For backwards compatibility; combines flags 'j' and 'n'.
RigDef::StrEqualsNocase
bool StrEqualsNocase(std::string const &s1, std::string const &s2)
Definition RigDef_Parser.cpp:60
RoR::App::GetConsole
Console * GetConsole()
Definition Application.cpp:289
RoR::WheelSide
WheelSide
Used by rig-def/addonpart/tuneup formats to specify wheel rim mesh orientation.
Definition Application.h:552
RoR::VideoCamRole
VideoCamRole
Definition Application.h:600
RoR::VCAM_ROLE_MIRROR
@ VCAM_ROLE_MIRROR
Flips the video output and when not in driver cam, acts like a natural mirror, not a screen.
Definition Application.h:605
RoR::VCAM_ROLE_INVALID
@ VCAM_ROLE_INVALID
Definition Application.h:615
RoR::VCAM_ROLE_TRACKING_VIDEOCAM
@ VCAM_ROLE_TRACKING_VIDEOCAM
Definition Application.h:604
RoR::VCAM_ROLE_MIRROR_NOFLIP
@ VCAM_ROLE_MIRROR_NOFLIP
Same as VCAM_ROLE_MIRROR, but without flipping the texture horizontally (expects texcoords to be alre...
Definition Application.h:606
RoR::VCAM_ROLE_VIDEOCAM
@ VCAM_ROLE_VIDEOCAM
Definition Application.h:603
RoR::ExtCameraMode
ExtCameraMode
Definition Application.h:561
RoR::WheelPropulsion
WheelPropulsion
Definition Application.h:542
RoR::WheelBraking
WheelBraking
Definition Application.h:531
RigDef::AeroAnimator::OPTION_THROTTLE
static const BitMask_t OPTION_THROTTLE
Definition RigDef_File.h:250
RigDef::AeroAnimator::engine_idx
unsigned int engine_idx
Definition RigDef_File.h:257
RigDef::AeroAnimator::OPTION_RPM
static const BitMask_t OPTION_RPM
Definition RigDef_File.h:251
RigDef::AeroAnimator::OPTION_TORQUE
static const BitMask_t OPTION_TORQUE
Definition RigDef_File.h:252
RigDef::AeroAnimator::OPTION_PITCH
static const BitMask_t OPTION_PITCH
Definition RigDef_File.h:253
RigDef::AeroAnimator::OPTION_STATUS
static const BitMask_t OPTION_STATUS
Definition RigDef_File.h:254
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::MotorSource::SOURCE_AERO_PITCH
static const BitMask_t SOURCE_AERO_PITCH
Definition RigDef_File.h:349
RigDef::Animation::MotorSource::SOURCE_AERO_STATUS
static const BitMask_t SOURCE_AERO_STATUS
Definition RigDef_File.h:350
RigDef::Animation::MotorSource::SOURCE_AERO_RPM
static const BitMask_t SOURCE_AERO_RPM
Definition RigDef_File.h:347
RigDef::Animation::MotorSource::SOURCE_AERO_TORQUE
static const BitMask_t SOURCE_AERO_TORQUE
Definition RigDef_File.h:348
RigDef::Animation::MotorSource::SOURCE_AERO_THROTTLE
static const BitMask_t SOURCE_AERO_THROTTLE
Definition RigDef_File.h:346
RigDef::Animation::MotorSource::SOURCE_GEAR_FORWARD
static const BitMask_t SOURCE_GEAR_FORWARD
Definition RigDef_File.h:352
RigDef::Animation::SOURCE_GEAR_REVERSE
static const BitMask64_t SOURCE_GEAR_REVERSE
Definition RigDef_File.h:395
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::SOURCE_AUTOSHIFTERLIN
static const BitMask64_t SOURCE_AUTOSHIFTERLIN
Definition RigDef_File.h:393
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::dash_link_name
Ogre::String dash_link_name
Definition RigDef_File.h:416
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_GEAR_NEUTRAL
static const BitMask64_t SOURCE_GEAR_NEUTRAL
Definition RigDef_File.h:394
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::motor_sources
std::list< MotorSource > motor_sources
Definition RigDef_File.h:413
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_DASHBOARD
static const BitMask64_t SOURCE_DASHBOARD
Definition RigDef_File.h:391
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::Animation::SOURCE_SIGNALSTALK
static const BitMask64_t SOURCE_SIGNALSTALK
Definition RigDef_File.h:392
RigDef::Animator::OPTION_ALTIMETER_100K
static const BitMask_t OPTION_ALTIMETER_100K
Definition RigDef_File.h:427
RigDef::Animator::OPTION_ALTIMETER_1K
static const BitMask_t OPTION_ALTIMETER_1K
Definition RigDef_File.h:429
RigDef::Animator::OPTION_SPEEDO
static const BitMask_t OPTION_SPEEDO
Definition RigDef_File.h:438
RigDef::Animator::OPTION_ACCEL
static const BitMask_t OPTION_ACCEL
Definition RigDef_File.h:436
RigDef::Animator::OPTION_AIR_BRAKE
static const BitMask_t OPTION_AIR_BRAKE
Definition RigDef_File.h:432
RigDef::Animator::OPTION_ANGLE_OF_ATTACK
static const BitMask_t OPTION_ANGLE_OF_ATTACK
Definition RigDef_File.h:430
RigDef::Animator::OPTION_BOAT_RUDDER
static const BitMask_t OPTION_BOAT_RUDDER
Definition RigDef_File.h:448
RigDef::Animator::OPTION_ROLL
static const BitMask_t OPTION_ROLL
Definition RigDef_File.h:433
RigDef::Animator::OPTION_SEQUENTIAL_SHIFT
static const BitMask_t OPTION_SEQUENTIAL_SHIFT
Definition RigDef_File.h:444
RigDef::Animator::OPTION_PARKING
static const BitMask_t OPTION_PARKING
Definition RigDef_File.h:441
RigDef::Animator::OPTION_VISIBLE
static const BitMask_t OPTION_VISIBLE
Definition RigDef_File.h:423
RigDef::Animator::OPTION_TURBO
static const BitMask_t OPTION_TURBO
Definition RigDef_File.h:440
RigDef::Animator::OPTION_SHIFT_BACK_FORTH
static const BitMask_t OPTION_SHIFT_BACK_FORTH
Definition RigDef_File.h:443
RigDef::Animator::OPTION_PITCH
static const BitMask_t OPTION_PITCH
Definition RigDef_File.h:434
RigDef::Animator::aero_animator
AeroAnimator aero_animator
Definition RigDef_File.h:458
RigDef::Animator::OPTION_AIRSPEED
static const BitMask_t OPTION_AIRSPEED
Definition RigDef_File.h:425
RigDef::Animator::inertia_defaults
std::shared_ptr< Inertia > inertia_defaults
Definition RigDef_File.h:459
RigDef::Animator::OPTION_BOAT_THROTTLE
static const BitMask_t OPTION_BOAT_THROTTLE
Definition RigDef_File.h:449
RigDef::Animator::OPTION_SHORT_LIMIT
static const BitMask_t OPTION_SHORT_LIMIT
Definition RigDef_File.h:450
RigDef::Animator::OPTION_ALTIMETER_10K
static const BitMask_t OPTION_ALTIMETER_10K
Definition RigDef_File.h:428
RigDef::Animator::OPTION_VERTICAL_VELOCITY
static const BitMask_t OPTION_VERTICAL_VELOCITY
Definition RigDef_File.h:426
RigDef::Animator::OPTION_FLAP
static const BitMask_t OPTION_FLAP
Definition RigDef_File.h:431
RigDef::Animator::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:460
RigDef::Animator::OPTION_DIFFLOCK
static const BitMask_t OPTION_DIFFLOCK
Definition RigDef_File.h:447
RigDef::Animator::OPTION_BRAKES
static const BitMask_t OPTION_BRAKES
Definition RigDef_File.h:435
RigDef::Animator::OPTION_TORQUE
static const BitMask_t OPTION_TORQUE
Definition RigDef_File.h:446
RigDef::Animator::OPTION_SHIFT_LEFT_RIGHT
static const BitMask_t OPTION_SHIFT_LEFT_RIGHT
Definition RigDef_File.h:442
RigDef::Animator::OPTION_LONG_LIMIT
static const BitMask_t OPTION_LONG_LIMIT
Definition RigDef_File.h:451
RigDef::Animator::OPTION_INVISIBLE
static const BitMask_t OPTION_INVISIBLE
Definition RigDef_File.h:424
RigDef::Animator::OPTION_CLUTCH
static const BitMask_t OPTION_CLUTCH
Definition RigDef_File.h:437
RigDef::Animator::nodes
Node::Ref nodes[2]
Definition RigDef_File.h:453
RigDef::Animator::OPTION_GEAR_SELECT
static const BitMask_t OPTION_GEAR_SELECT
Definition RigDef_File.h:445
RigDef::Animator::OPTION_TACHO
static const BitMask_t OPTION_TACHO
Definition RigDef_File.h:439
RigDef::Assetpack::filename
std::string filename
Definition RigDef_File.h:262
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::scale
BeamDefaultsScale scale
Definition RigDef_File.h:564
RigDef::BeamDefaults::_is_plastic_deform_coef_user_defined
bool _is_plastic_deform_coef_user_defined
Definition RigDef_File.h:562
RigDef::BeamDefaults::beam_material_name
Ogre::String beam_material_name
Definition RigDef_File.h:559
RigDef::BeamDefaults::_is_user_defined
bool _is_user_defined
Informs whether these data were read from "set_beam_defaults" directive or filled in by the parser on...
Definition RigDef_File.h:563
RigDef::BeamDefaults::_enable_advanced_deformation
bool _enable_advanced_deformation
Informs whether "enable_advanced_deformation" directive preceded these defaults.
Definition RigDef_File.h:561
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::nodes
Node::Ref nodes[3]
Definition RigDef_File.h:585
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::options
BitMask_t options
Definition RigDef_File.h:586
RigDef::Cab::OPTION_u_INVULNERABLE
static const BitMask_t OPTION_u_INVULNERABLE
Definition RigDef_File.h:578
RigDef::Camera::left_node
Node::Ref left_node
Definition RigDef_File.h:593
RigDef::Camera::center_node
Node::Ref center_node
Definition RigDef_File.h:591
RigDef::Camera::back_node
Node::Ref back_node
Definition RigDef_File.h:592
RigDef::Cinecam::position
Ogre::Vector3 position
Definition RigDef_File.h:608
RigDef::Cinecam::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:613
RigDef::Cinecam::nodes
Node::Ref nodes[8]
Definition RigDef_File.h:609
RigDef::Cinecam::node_defaults
std::shared_ptr< NodeDefaults > node_defaults
Definition RigDef_File.h:614
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::inertia_defaults
std::shared_ptr< Inertia > inertia_defaults
Definition RigDef_File.h:642
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::DefaultSkin::skin_name
std::string skin_name
Definition RigDef_File.h:672
RigDef::DocComment
< Represents a comment (line starting with ';' or '//') that can be anywhere in the file.
Definition RigDef_File.h:312
RigDef::DocComment::commented_datapos
int commented_datapos
Position in the data vector for the given keyword.
Definition RigDef_File.h:316
RigDef::DocComment::comment_text
std::string comment_text
May contain multiple lines separated by ' ' - MUST contain leading ';' or '//' at each line!
Definition RigDef_File.h:313
RigDef::DocComment::commented_keyword
RigDef::Keyword commented_keyword
Definition RigDef_File.h:315
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::Flare3::inertia_defaults
std::shared_ptr< Inertia > inertia_defaults
Definition RigDef_File.h:766
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::dashboard_link
std::string dashboard_link
Only 'd' type flares.
Definition RigDef_File.h:754
RigDef::FlareBase::node_axis_y
Node::Ref node_axis_y
Definition RigDef_File.h:750
RigDef::FlaregroupNoImport::control_number
int control_number
Only 'u' type flares.
Definition RigDef_File.h:772
RigDef::FlexBodyWheel
Definition RigDef_File.h:801
RigDef::FlexBodyWheel::tyre_mesh_name
Ogre::String tyre_mesh_name
Definition RigDef_File.h:806
RigDef::FlexBodyWheel::side
RoR::WheelSide side
Definition RigDef_File.h:802
RigDef::FlexBodyWheel::rim_mesh_name
Ogre::String rim_mesh_name
Definition RigDef_File.h:805
RigDef::FlexBodyWheel::rim_springiness
float rim_springiness
Definition RigDef_File.h:803
RigDef::FlexBodyWheel::rim_damping
float rim_damping
Definition RigDef_File.h:804
RigDef::Flexbody::node_list_to_import
std::vector< Node::Range > node_list_to_import
Definition RigDef_File.h:794
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::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::Forvert
Manually specified (vert => node) bindings for flexbody deformation (overrides 'forset').
Definition RigDef_File.h:777
RigDef::Forvert::node_ref
Node::Ref node_ref
Definition RigDef_File.h:778
RigDef::Forvert::node_y
Node::Ref node_y
Definition RigDef_File.h:780
RigDef::Forvert::node_x
Node::Ref node_x
Definition RigDef_File.h:779
RigDef::Fusedrag::rear_node
Node::Ref rear_node
Definition RigDef_File.h:815
RigDef::Fusedrag::airfoil_name
Ogre::String airfoil_name
Definition RigDef_File.h:817
RigDef::Fusedrag::front_node
Node::Ref front_node
Definition RigDef_File.h:814
RigDef::Globals::material_name
Ogre::String material_name
Definition RigDef_File.h:825
RigDef::Guid::guid
std::string guid
Definition RigDef_File.h:830
RigDef::Help::material
std::string material
Definition RigDef_File.h:841
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::inertia_defaults
std::shared_ptr< Inertia > inertia_defaults
Definition RigDef_File.h:885
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::type
ManagedMaterialType type
Definition RigDef_File.h:915
RigDef::ManagedMaterial::options
ManagedMaterialsOptions options
Definition RigDef_File.h:916
RigDef::ManagedMaterial::specular_map
Ogre::String specular_map
Definition RigDef_File.h:919
RigDef::ManagedMaterial::damaged_diffuse_map
Ogre::String damaged_diffuse_map
Definition RigDef_File.h:918
RigDef::Minimass::global_min_mass_Kg
float global_min_mass_Kg
minimum node mass in Kg - only effective where DefaultMinimass was not set.
Definition RigDef_File.h:932
RigDef::Minimass::option
MinimassOption option
Definition RigDef_File.h:933
RigDef::Node::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_Node.h:165
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::Pistonprop::reference_node
Node::Ref reference_node
Definition RigDef_File.h:962
RigDef::Pistonprop::airfoil
Ogre::String airfoil
Definition RigDef_File.h:968
RigDef::Pistonprop::couple_node
Node::Ref couple_node
Definition RigDef_File.h:965
RigDef::Pistonprop::blade_tip_nodes
Node::Ref blade_tip_nodes[4]
Definition RigDef_File.h:964
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::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::inertia_defaults
std::shared_ptr< Inertia > inertia_defaults
Definition RigDef_File.h:1043
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::Script::filename
std::string filename
Definition RigDef_File.h:1065
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::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1218
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::beam_defaults
std::shared_ptr< BeamDefaults > beam_defaults
Definition RigDef_File.h:1281
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::Turbojet::front_node
Node::Ref front_node
Definition RigDef_File.h:1289
RigDef::Turbojet::back_node
Node::Ref back_node
Definition RigDef_File.h:1290
RigDef::Turbojet::side_node
Node::Ref side_node
Definition RigDef_File.h:1291
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::Wheel2::face_material_name
Ogre::String face_material_name
Definition RigDef_File.h:1343
RigDef::Wheel2::band_material_name
Ogre::String band_material_name
Definition RigDef_File.h:1344
RigDef::Wheel::band_material_name
Ogre::String band_material_name
Definition RigDef_File.h:1336
RigDef::Wheel::face_material_name
Ogre::String face_material_name
Definition RigDef_File.h:1335
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