diff options
Diffstat (limited to 'OpenSim/Region/Framework/Scenes/SOPVehicle.cs')
-rw-r--r-- | OpenSim/Region/Framework/Scenes/SOPVehicle.cs | 487 |
1 files changed, 487 insertions, 0 deletions
diff --git a/OpenSim/Region/Framework/Scenes/SOPVehicle.cs b/OpenSim/Region/Framework/Scenes/SOPVehicle.cs new file mode 100644 index 0000000..39786bd --- /dev/null +++ b/OpenSim/Region/Framework/Scenes/SOPVehicle.cs | |||
@@ -0,0 +1,487 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using OpenMetaverse; | ||
30 | using OpenSim.Framework; | ||
31 | using OpenSim.Region.Physics.Manager; | ||
32 | using System.Xml; | ||
33 | using OpenSim.Framework.Serialization; | ||
34 | using OpenSim.Framework.Serialization.External; | ||
35 | using OpenSim.Region.Framework.Scenes.Serialization; | ||
36 | |||
37 | namespace OpenSim.Region.Framework.Scenes | ||
38 | { | ||
39 | public class SOPVehicle | ||
40 | { | ||
41 | public VehicleData vd; | ||
42 | |||
43 | public Vehicle Type | ||
44 | { | ||
45 | get { return vd.m_type; } | ||
46 | } | ||
47 | |||
48 | public SOPVehicle() | ||
49 | { | ||
50 | vd = new VehicleData(); | ||
51 | ProcessTypeChange(Vehicle.TYPE_NONE); // is needed? | ||
52 | } | ||
53 | |||
54 | public void ProcessFloatVehicleParam(Vehicle pParam, float pValue) | ||
55 | { | ||
56 | float len; | ||
57 | float timestep = 0.01f; | ||
58 | switch (pParam) | ||
59 | { | ||
60 | case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: | ||
61 | if (pValue < 0f) pValue = 0f; | ||
62 | if (pValue > 1f) pValue = 1f; | ||
63 | vd.m_angularDeflectionEfficiency = pValue; | ||
64 | break; | ||
65 | case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: | ||
66 | if (pValue < timestep) pValue = timestep; | ||
67 | vd.m_angularDeflectionTimescale = pValue; | ||
68 | break; | ||
69 | case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: | ||
70 | if (pValue < timestep) pValue = timestep; | ||
71 | else if (pValue > 120) pValue = 120; | ||
72 | vd.m_angularMotorDecayTimescale = pValue; | ||
73 | break; | ||
74 | case Vehicle.ANGULAR_MOTOR_TIMESCALE: | ||
75 | if (pValue < timestep) pValue = timestep; | ||
76 | vd.m_angularMotorTimescale = pValue; | ||
77 | break; | ||
78 | case Vehicle.BANKING_EFFICIENCY: | ||
79 | if (pValue < -1f) pValue = -1f; | ||
80 | if (pValue > 1f) pValue = 1f; | ||
81 | vd.m_bankingEfficiency = pValue; | ||
82 | break; | ||
83 | case Vehicle.BANKING_MIX: | ||
84 | if (pValue < 0f) pValue = 0f; | ||
85 | if (pValue > 1f) pValue = 1f; | ||
86 | vd.m_bankingMix = pValue; | ||
87 | break; | ||
88 | case Vehicle.BANKING_TIMESCALE: | ||
89 | if (pValue < timestep) pValue = timestep; | ||
90 | vd.m_bankingTimescale = pValue; | ||
91 | break; | ||
92 | case Vehicle.BUOYANCY: | ||
93 | if (pValue < -1f) pValue = -1f; | ||
94 | if (pValue > 1f) pValue = 1f; | ||
95 | vd.m_VehicleBuoyancy = pValue; | ||
96 | break; | ||
97 | case Vehicle.HOVER_EFFICIENCY: | ||
98 | if (pValue < 0f) pValue = 0f; | ||
99 | if (pValue > 1f) pValue = 1f; | ||
100 | vd.m_VhoverEfficiency = pValue; | ||
101 | break; | ||
102 | case Vehicle.HOVER_HEIGHT: | ||
103 | vd.m_VhoverHeight = pValue; | ||
104 | break; | ||
105 | case Vehicle.HOVER_TIMESCALE: | ||
106 | if (pValue < timestep) pValue = timestep; | ||
107 | vd.m_VhoverTimescale = pValue; | ||
108 | break; | ||
109 | case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: | ||
110 | if (pValue < 0f) pValue = 0f; | ||
111 | if (pValue > 1f) pValue = 1f; | ||
112 | vd.m_linearDeflectionEfficiency = pValue; | ||
113 | break; | ||
114 | case Vehicle.LINEAR_DEFLECTION_TIMESCALE: | ||
115 | if (pValue < timestep) pValue = timestep; | ||
116 | vd.m_linearDeflectionTimescale = pValue; | ||
117 | break; | ||
118 | case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: | ||
119 | // if (pValue < timestep) pValue = timestep; | ||
120 | // try to make impulses to work a bit better | ||
121 | if (pValue < timestep) pValue = timestep; | ||
122 | else if (pValue > 120) pValue = 120; | ||
123 | vd.m_linearMotorDecayTimescale = pValue; | ||
124 | break; | ||
125 | case Vehicle.LINEAR_MOTOR_TIMESCALE: | ||
126 | if (pValue < timestep) pValue = timestep; | ||
127 | vd.m_linearMotorTimescale = pValue; | ||
128 | break; | ||
129 | case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: | ||
130 | if (pValue < 0f) pValue = 0f; | ||
131 | if (pValue > 1f) pValue = 1f; | ||
132 | vd.m_verticalAttractionEfficiency = pValue; | ||
133 | break; | ||
134 | case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: | ||
135 | if (pValue < timestep) pValue = timestep; | ||
136 | vd.m_verticalAttractionTimescale = pValue; | ||
137 | break; | ||
138 | |||
139 | // These are vector properties but the engine lets you use a single float value to | ||
140 | // set all of the components to the same value | ||
141 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: | ||
142 | if (pValue < timestep) pValue = timestep; | ||
143 | vd.m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue); | ||
144 | break; | ||
145 | case Vehicle.ANGULAR_MOTOR_DIRECTION: | ||
146 | vd.m_angularMotorDirection = new Vector3(pValue, pValue, pValue); | ||
147 | len = vd.m_angularMotorDirection.Length(); | ||
148 | if (len > 12.566f) | ||
149 | vd.m_angularMotorDirection *= (12.566f / len); | ||
150 | break; | ||
151 | case Vehicle.LINEAR_FRICTION_TIMESCALE: | ||
152 | if (pValue < timestep) pValue = timestep; | ||
153 | vd.m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue); | ||
154 | break; | ||
155 | case Vehicle.LINEAR_MOTOR_DIRECTION: | ||
156 | vd.m_linearMotorDirection = new Vector3(pValue, pValue, pValue); | ||
157 | len = vd.m_linearMotorDirection.Length(); | ||
158 | if (len > 30.0f) | ||
159 | vd.m_linearMotorDirection *= (30.0f / len); | ||
160 | break; | ||
161 | case Vehicle.LINEAR_MOTOR_OFFSET: | ||
162 | vd.m_linearMotorOffset = new Vector3(pValue, pValue, pValue); | ||
163 | len = vd.m_linearMotorOffset.Length(); | ||
164 | if (len > 100.0f) | ||
165 | vd.m_linearMotorOffset *= (100.0f / len); | ||
166 | break; | ||
167 | } | ||
168 | }//end ProcessFloatVehicleParam | ||
169 | |||
170 | public void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue) | ||
171 | { | ||
172 | float len; | ||
173 | float timestep = 0.01f; | ||
174 | switch (pParam) | ||
175 | { | ||
176 | case Vehicle.ANGULAR_FRICTION_TIMESCALE: | ||
177 | if (pValue.X < timestep) pValue.X = timestep; | ||
178 | if (pValue.Y < timestep) pValue.Y = timestep; | ||
179 | if (pValue.Z < timestep) pValue.Z = timestep; | ||
180 | |||
181 | vd.m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
182 | break; | ||
183 | case Vehicle.ANGULAR_MOTOR_DIRECTION: | ||
184 | vd.m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
185 | // Limit requested angular speed to 2 rps= 4 pi rads/sec | ||
186 | len = vd.m_angularMotorDirection.Length(); | ||
187 | if (len > 12.566f) | ||
188 | vd.m_angularMotorDirection *= (12.566f / len); | ||
189 | break; | ||
190 | case Vehicle.LINEAR_FRICTION_TIMESCALE: | ||
191 | if (pValue.X < timestep) pValue.X = timestep; | ||
192 | if (pValue.Y < timestep) pValue.Y = timestep; | ||
193 | if (pValue.Z < timestep) pValue.Z = timestep; | ||
194 | vd.m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
195 | break; | ||
196 | case Vehicle.LINEAR_MOTOR_DIRECTION: | ||
197 | vd.m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
198 | len = vd.m_linearMotorDirection.Length(); | ||
199 | if (len > 30.0f) | ||
200 | vd.m_linearMotorDirection *= (30.0f / len); | ||
201 | break; | ||
202 | case Vehicle.LINEAR_MOTOR_OFFSET: | ||
203 | vd.m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z); | ||
204 | len = vd.m_linearMotorOffset.Length(); | ||
205 | if (len > 100.0f) | ||
206 | vd.m_linearMotorOffset *= (100.0f / len); | ||
207 | break; | ||
208 | } | ||
209 | }//end ProcessVectorVehicleParam | ||
210 | |||
211 | public void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) | ||
212 | { | ||
213 | switch (pParam) | ||
214 | { | ||
215 | case Vehicle.REFERENCE_FRAME: | ||
216 | vd.m_referenceFrame = Quaternion.Inverse(pValue); | ||
217 | break; | ||
218 | } | ||
219 | }//end ProcessRotationVehicleParam | ||
220 | |||
221 | public void ProcessVehicleFlags(int pParam, bool remove) | ||
222 | { | ||
223 | if (remove) | ||
224 | { | ||
225 | vd.m_flags &= ~((VehicleFlag)pParam); | ||
226 | } | ||
227 | else | ||
228 | { | ||
229 | vd.m_flags |= (VehicleFlag)pParam; | ||
230 | } | ||
231 | }//end ProcessVehicleFlags | ||
232 | |||
233 | public void ProcessTypeChange(Vehicle pType) | ||
234 | { | ||
235 | vd.m_linearMotorDirection = Vector3.Zero; | ||
236 | vd.m_angularMotorDirection = Vector3.Zero; | ||
237 | vd.m_linearMotorOffset = Vector3.Zero; | ||
238 | vd.m_referenceFrame = Quaternion.Identity; | ||
239 | |||
240 | // Set Defaults For Type | ||
241 | vd.m_type = pType; | ||
242 | switch (pType) | ||
243 | { | ||
244 | case Vehicle.TYPE_NONE: | ||
245 | vd.m_linearFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
246 | vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
247 | vd.m_linearMotorTimescale = 1000; | ||
248 | vd.m_linearMotorDecayTimescale = 120; | ||
249 | vd.m_angularMotorTimescale = 1000; | ||
250 | vd.m_angularMotorDecayTimescale = 1000; | ||
251 | vd.m_VhoverHeight = 0; | ||
252 | vd.m_VhoverEfficiency = 1; | ||
253 | vd.m_VhoverTimescale = 1000; | ||
254 | vd.m_VehicleBuoyancy = 0; | ||
255 | vd.m_linearDeflectionEfficiency = 0; | ||
256 | vd.m_linearDeflectionTimescale = 1000; | ||
257 | vd.m_angularDeflectionEfficiency = 0; | ||
258 | vd.m_angularDeflectionTimescale = 1000; | ||
259 | vd.m_bankingEfficiency = 0; | ||
260 | vd.m_bankingMix = 1; | ||
261 | vd.m_bankingTimescale = 1000; | ||
262 | vd.m_verticalAttractionEfficiency = 0; | ||
263 | vd.m_verticalAttractionTimescale = 1000; | ||
264 | |||
265 | vd.m_flags = (VehicleFlag)0; | ||
266 | break; | ||
267 | |||
268 | case Vehicle.TYPE_SLED: | ||
269 | vd.m_linearFrictionTimescale = new Vector3(30, 1, 1000); | ||
270 | vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
271 | vd.m_linearMotorTimescale = 1000; | ||
272 | vd.m_linearMotorDecayTimescale = 120; | ||
273 | vd.m_angularMotorTimescale = 1000; | ||
274 | vd.m_angularMotorDecayTimescale = 120; | ||
275 | vd.m_VhoverHeight = 0; | ||
276 | vd.m_VhoverEfficiency = 1; | ||
277 | vd.m_VhoverTimescale = 10; | ||
278 | vd.m_VehicleBuoyancy = 0; | ||
279 | vd.m_linearDeflectionEfficiency = 1; | ||
280 | vd.m_linearDeflectionTimescale = 1; | ||
281 | vd.m_angularDeflectionEfficiency = 0; | ||
282 | vd.m_angularDeflectionTimescale = 1000; | ||
283 | vd.m_bankingEfficiency = 0; | ||
284 | vd.m_bankingMix = 1; | ||
285 | vd.m_bankingTimescale = 10; | ||
286 | vd.m_flags &= | ||
287 | ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | | ||
288 | VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY); | ||
289 | vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP); | ||
290 | break; | ||
291 | case Vehicle.TYPE_CAR: | ||
292 | vd.m_linearFrictionTimescale = new Vector3(100, 2, 1000); | ||
293 | vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000); | ||
294 | vd.m_linearMotorTimescale = 1; | ||
295 | vd.m_linearMotorDecayTimescale = 60; | ||
296 | vd.m_angularMotorTimescale = 1; | ||
297 | vd.m_angularMotorDecayTimescale = 0.8f; | ||
298 | vd.m_VhoverHeight = 0; | ||
299 | vd.m_VhoverEfficiency = 0; | ||
300 | vd.m_VhoverTimescale = 1000; | ||
301 | vd.m_VehicleBuoyancy = 0; | ||
302 | vd.m_linearDeflectionEfficiency = 1; | ||
303 | vd.m_linearDeflectionTimescale = 2; | ||
304 | vd.m_angularDeflectionEfficiency = 0; | ||
305 | vd.m_angularDeflectionTimescale = 10; | ||
306 | vd.m_verticalAttractionEfficiency = 1f; | ||
307 | vd.m_verticalAttractionTimescale = 10f; | ||
308 | vd.m_bankingEfficiency = -0.2f; | ||
309 | vd.m_bankingMix = 1; | ||
310 | vd.m_bankingTimescale = 1; | ||
311 | vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
312 | vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | | ||
313 | VehicleFlag.LIMIT_MOTOR_UP | VehicleFlag.HOVER_UP_ONLY); | ||
314 | break; | ||
315 | case Vehicle.TYPE_BOAT: | ||
316 | vd.m_linearFrictionTimescale = new Vector3(10, 3, 2); | ||
317 | vd.m_angularFrictionTimescale = new Vector3(10, 10, 10); | ||
318 | vd.m_linearMotorTimescale = 5; | ||
319 | vd.m_linearMotorDecayTimescale = 60; | ||
320 | vd.m_angularMotorTimescale = 4; | ||
321 | vd.m_angularMotorDecayTimescale = 4; | ||
322 | vd.m_VhoverHeight = 0; | ||
323 | vd.m_VhoverEfficiency = 0.5f; | ||
324 | vd.m_VhoverTimescale = 2; | ||
325 | vd.m_VehicleBuoyancy = 1; | ||
326 | vd.m_linearDeflectionEfficiency = 0.5f; | ||
327 | vd.m_linearDeflectionTimescale = 3; | ||
328 | vd.m_angularDeflectionEfficiency = 0.5f; | ||
329 | vd.m_angularDeflectionTimescale = 5; | ||
330 | vd.m_verticalAttractionEfficiency = 0.5f; | ||
331 | vd.m_verticalAttractionTimescale = 5f; | ||
332 | vd.m_bankingEfficiency = -0.3f; | ||
333 | vd.m_bankingMix = 0.8f; | ||
334 | vd.m_bankingTimescale = 1; | ||
335 | vd.m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | | ||
336 | VehicleFlag.HOVER_GLOBAL_HEIGHT | | ||
337 | VehicleFlag.HOVER_UP_ONLY | | ||
338 | VehicleFlag.LIMIT_ROLL_ONLY); | ||
339 | vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP | | ||
340 | VehicleFlag.LIMIT_MOTOR_UP | | ||
341 | VehicleFlag.HOVER_WATER_ONLY); | ||
342 | break; | ||
343 | case Vehicle.TYPE_AIRPLANE: | ||
344 | vd.m_linearFrictionTimescale = new Vector3(200, 10, 5); | ||
345 | vd.m_angularFrictionTimescale = new Vector3(20, 20, 20); | ||
346 | vd.m_linearMotorTimescale = 2; | ||
347 | vd.m_linearMotorDecayTimescale = 60; | ||
348 | vd.m_angularMotorTimescale = 4; | ||
349 | vd.m_angularMotorDecayTimescale = 8; | ||
350 | vd.m_VhoverHeight = 0; | ||
351 | vd.m_VhoverEfficiency = 0.5f; | ||
352 | vd.m_VhoverTimescale = 1000; | ||
353 | vd.m_VehicleBuoyancy = 0; | ||
354 | vd.m_linearDeflectionEfficiency = 0.5f; | ||
355 | vd.m_linearDeflectionTimescale = 0.5f; | ||
356 | vd.m_angularDeflectionEfficiency = 1; | ||
357 | vd.m_angularDeflectionTimescale = 2; | ||
358 | vd.m_verticalAttractionEfficiency = 0.9f; | ||
359 | vd.m_verticalAttractionTimescale = 2f; | ||
360 | vd.m_bankingEfficiency = 1; | ||
361 | vd.m_bankingMix = 0.7f; | ||
362 | vd.m_bankingTimescale = 2; | ||
363 | vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | | ||
364 | VehicleFlag.HOVER_TERRAIN_ONLY | | ||
365 | VehicleFlag.HOVER_GLOBAL_HEIGHT | | ||
366 | VehicleFlag.HOVER_UP_ONLY | | ||
367 | VehicleFlag.NO_DEFLECTION_UP | | ||
368 | VehicleFlag.LIMIT_MOTOR_UP); | ||
369 | vd.m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY); | ||
370 | break; | ||
371 | case Vehicle.TYPE_BALLOON: | ||
372 | vd.m_linearFrictionTimescale = new Vector3(5, 5, 5); | ||
373 | vd.m_angularFrictionTimescale = new Vector3(10, 10, 10); | ||
374 | vd.m_linearMotorTimescale = 5; | ||
375 | vd.m_linearMotorDecayTimescale = 60; | ||
376 | vd.m_angularMotorTimescale = 6; | ||
377 | vd.m_angularMotorDecayTimescale = 10; | ||
378 | vd.m_VhoverHeight = 5; | ||
379 | vd.m_VhoverEfficiency = 0.8f; | ||
380 | vd.m_VhoverTimescale = 10; | ||
381 | vd.m_VehicleBuoyancy = 1; | ||
382 | vd.m_linearDeflectionEfficiency = 0; | ||
383 | vd.m_linearDeflectionTimescale = 5; | ||
384 | vd.m_angularDeflectionEfficiency = 0; | ||
385 | vd.m_angularDeflectionTimescale = 5; | ||
386 | vd.m_verticalAttractionEfficiency = 0f; | ||
387 | vd.m_verticalAttractionTimescale = 1000f; | ||
388 | vd.m_bankingEfficiency = 0; | ||
389 | vd.m_bankingMix = 0.7f; | ||
390 | vd.m_bankingTimescale = 5; | ||
391 | vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | | ||
392 | VehicleFlag.HOVER_TERRAIN_ONLY | | ||
393 | VehicleFlag.HOVER_UP_ONLY | | ||
394 | VehicleFlag.NO_DEFLECTION_UP | | ||
395 | VehicleFlag.LIMIT_MOTOR_UP); | ||
396 | vd.m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | | ||
397 | VehicleFlag.HOVER_GLOBAL_HEIGHT); | ||
398 | break; | ||
399 | } | ||
400 | } | ||
401 | public void SetVehicle(PhysicsActor ph) | ||
402 | { | ||
403 | if (ph == null) | ||
404 | return; | ||
405 | ph.SetVehicle(vd); | ||
406 | } | ||
407 | |||
408 | private XmlTextWriter writer; | ||
409 | |||
410 | private void XWint(string name, int i) | ||
411 | { | ||
412 | writer.WriteElementString(name, i.ToString()); | ||
413 | } | ||
414 | |||
415 | private void XWfloat(string name, float f) | ||
416 | { | ||
417 | writer.WriteElementString(name, f.ToString(Utils.EnUsCulture)); | ||
418 | } | ||
419 | |||
420 | private void XWVector(string name, Vector3 vec) | ||
421 | { | ||
422 | writer.WriteStartElement(name); | ||
423 | writer.WriteElementString("X", vec.X.ToString(Utils.EnUsCulture)); | ||
424 | writer.WriteElementString("Y", vec.Y.ToString(Utils.EnUsCulture)); | ||
425 | writer.WriteElementString("Z", vec.Z.ToString(Utils.EnUsCulture)); | ||
426 | writer.WriteEndElement(); | ||
427 | } | ||
428 | |||
429 | private void XWQuat(string name, Quaternion quat) | ||
430 | { | ||
431 | writer.WriteStartElement(name); | ||
432 | writer.WriteElementString("X", quat.X.ToString(Utils.EnUsCulture)); | ||
433 | writer.WriteElementString("Y", quat.Y.ToString(Utils.EnUsCulture)); | ||
434 | writer.WriteElementString("Z", quat.Z.ToString(Utils.EnUsCulture)); | ||
435 | writer.WriteElementString("W", quat.W.ToString(Utils.EnUsCulture)); | ||
436 | writer.WriteEndElement(); | ||
437 | } | ||
438 | |||
439 | public void ToXml2(XmlTextWriter twriter) | ||
440 | { | ||
441 | writer = twriter; | ||
442 | writer.WriteStartElement("SOGVehicle"); | ||
443 | |||
444 | XWint("TYPE", (int)vd.m_type); | ||
445 | XWint("FLAGS", (int)vd.m_flags); | ||
446 | |||
447 | // Linear properties | ||
448 | XWVector("LMDIR", vd.m_linearMotorDirection); | ||
449 | XWVector("LMFTIME", vd.m_linearFrictionTimescale); | ||
450 | XWfloat("LMDTIME", vd.m_linearMotorDecayTimescale); | ||
451 | XWfloat("LMTIME", vd.m_linearMotorTimescale); | ||
452 | XWVector("LMOFF", vd.m_linearMotorOffset); | ||
453 | |||
454 | //Angular properties | ||
455 | XWVector("AMDIR", vd.m_angularMotorDirection); | ||
456 | XWfloat("AMTIME", vd.m_angularMotorTimescale); | ||
457 | XWfloat("AMDTIME", vd.m_angularMotorDecayTimescale); | ||
458 | XWVector("AMFTIME", vd.m_angularFrictionTimescale); | ||
459 | |||
460 | //Deflection properties | ||
461 | XWfloat("ADEFF", vd.m_angularDeflectionEfficiency); | ||
462 | XWfloat("ADTIME", vd.m_angularDeflectionTimescale); | ||
463 | XWfloat("LDEFF", vd.m_linearDeflectionEfficiency); | ||
464 | XWfloat("LDTIME", vd.m_linearDeflectionTimescale); | ||
465 | |||
466 | //Banking properties | ||
467 | XWfloat("BEFF", vd.m_bankingEfficiency); | ||
468 | XWfloat("BMIX", vd.m_bankingMix); | ||
469 | XWfloat("BTIME", vd.m_bankingTimescale); | ||
470 | |||
471 | //Hover and Buoyancy properties | ||
472 | XWfloat("HHEI", vd.m_VhoverHeight); | ||
473 | XWfloat("HEFF", vd.m_VhoverEfficiency); | ||
474 | XWfloat("HTIME", vd.m_VhoverTimescale); | ||
475 | XWfloat("VBUO", vd.m_VehicleBuoyancy); | ||
476 | |||
477 | //Attractor properties | ||
478 | XWfloat("VAEFF", vd.m_verticalAttractionEfficiency); | ||
479 | XWfloat("VATIME", vd.m_verticalAttractionTimescale); | ||
480 | |||
481 | XWQuat("REF_FRAME", vd.m_referenceFrame); | ||
482 | |||
483 | writer.WriteEndElement(); | ||
484 | writer = null; | ||
485 | } | ||
486 | } | ||
487 | } \ No newline at end of file | ||