diff options
author | Melanie | 2013-06-06 02:25:19 +0100 |
---|---|---|
committer | Melanie | 2013-06-06 02:25:19 +0100 |
commit | e1d98c9e4c579c9feb6bcc4e7473e2372f496fdb (patch) | |
tree | f56e13a79fae8bbc671765b3e22f99d9e0e6c036 /OpenSim/Region/Framework/Scenes/KeyframeMotion.cs | |
parent | Merge branch 'master' of /home/opensim/var/repo/opensim (diff) | |
download | opensim-SC_OLD-e1d98c9e4c579c9feb6bcc4e7473e2372f496fdb.zip opensim-SC_OLD-e1d98c9e4c579c9feb6bcc4e7473e2372f496fdb.tar.gz opensim-SC_OLD-e1d98c9e4c579c9feb6bcc4e7473e2372f496fdb.tar.bz2 opensim-SC_OLD-e1d98c9e4c579c9feb6bcc4e7473e2372f496fdb.tar.xz |
Committing Avination's Keyframe module. This is not hooked up yet and will do nothing. More commits to follow.
Diffstat (limited to 'OpenSim/Region/Framework/Scenes/KeyframeMotion.cs')
-rw-r--r-- | OpenSim/Region/Framework/Scenes/KeyframeMotion.cs | 766 |
1 files changed, 766 insertions, 0 deletions
diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs new file mode 100644 index 0000000..d773ee7 --- /dev/null +++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs | |||
@@ -0,0 +1,766 @@ | |||
1 | // Proprietary code of Avination Virtual Limited | ||
2 | // (c) 2012 Melanie Thielker | ||
3 | // | ||
4 | |||
5 | using System; | ||
6 | using System.Timers; | ||
7 | using System.Collections; | ||
8 | using System.Collections.Generic; | ||
9 | using System.IO; | ||
10 | using System.Diagnostics; | ||
11 | using System.Reflection; | ||
12 | using System.Threading; | ||
13 | using OpenMetaverse; | ||
14 | using OpenSim.Framework; | ||
15 | using OpenSim.Region.Framework.Interfaces; | ||
16 | using OpenSim.Region.Physics.Manager; | ||
17 | using OpenSim.Region.Framework.Scenes.Serialization; | ||
18 | using System.Runtime.Serialization.Formatters.Binary; | ||
19 | using System.Runtime.Serialization; | ||
20 | using Timer = System.Timers.Timer; | ||
21 | using log4net; | ||
22 | |||
23 | namespace OpenSim.Region.Framework.Scenes | ||
24 | { | ||
25 | public class KeyframeTimer | ||
26 | { | ||
27 | private static Dictionary<Scene, KeyframeTimer>m_timers = | ||
28 | new Dictionary<Scene, KeyframeTimer>(); | ||
29 | |||
30 | private Timer m_timer; | ||
31 | private Dictionary<KeyframeMotion, object> m_motions = new Dictionary<KeyframeMotion, object>(); | ||
32 | private object m_lockObject = new object(); | ||
33 | private object m_timerLock = new object(); | ||
34 | private const double m_tickDuration = 50.0; | ||
35 | private Scene m_scene; | ||
36 | |||
37 | public double TickDuration | ||
38 | { | ||
39 | get { return m_tickDuration; } | ||
40 | } | ||
41 | |||
42 | public KeyframeTimer(Scene scene) | ||
43 | { | ||
44 | m_timer = new Timer(); | ||
45 | m_timer.Interval = TickDuration; | ||
46 | m_timer.AutoReset = true; | ||
47 | m_timer.Elapsed += OnTimer; | ||
48 | |||
49 | m_scene = scene; | ||
50 | |||
51 | m_timer.Start(); | ||
52 | } | ||
53 | |||
54 | private void OnTimer(object sender, ElapsedEventArgs ea) | ||
55 | { | ||
56 | if (!Monitor.TryEnter(m_timerLock)) | ||
57 | return; | ||
58 | |||
59 | try | ||
60 | { | ||
61 | List<KeyframeMotion> motions; | ||
62 | |||
63 | lock (m_lockObject) | ||
64 | { | ||
65 | motions = new List<KeyframeMotion>(m_motions.Keys); | ||
66 | } | ||
67 | |||
68 | foreach (KeyframeMotion m in motions) | ||
69 | { | ||
70 | try | ||
71 | { | ||
72 | m.OnTimer(TickDuration); | ||
73 | } | ||
74 | catch (Exception inner) | ||
75 | { | ||
76 | // Don't stop processing | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | catch (Exception e) | ||
81 | { | ||
82 | // Keep running no matter what | ||
83 | } | ||
84 | finally | ||
85 | { | ||
86 | Monitor.Exit(m_timerLock); | ||
87 | } | ||
88 | } | ||
89 | |||
90 | public static void Add(KeyframeMotion motion) | ||
91 | { | ||
92 | KeyframeTimer timer; | ||
93 | |||
94 | if (motion.Scene == null) | ||
95 | return; | ||
96 | |||
97 | lock (m_timers) | ||
98 | { | ||
99 | if (!m_timers.TryGetValue(motion.Scene, out timer)) | ||
100 | { | ||
101 | timer = new KeyframeTimer(motion.Scene); | ||
102 | m_timers[motion.Scene] = timer; | ||
103 | } | ||
104 | } | ||
105 | |||
106 | lock (timer.m_lockObject) | ||
107 | { | ||
108 | timer.m_motions[motion] = null; | ||
109 | } | ||
110 | } | ||
111 | |||
112 | public static void Remove(KeyframeMotion motion) | ||
113 | { | ||
114 | KeyframeTimer timer; | ||
115 | |||
116 | if (motion.Scene == null) | ||
117 | return; | ||
118 | |||
119 | lock (m_timers) | ||
120 | { | ||
121 | if (!m_timers.TryGetValue(motion.Scene, out timer)) | ||
122 | { | ||
123 | return; | ||
124 | } | ||
125 | } | ||
126 | |||
127 | lock (timer.m_lockObject) | ||
128 | { | ||
129 | timer.m_motions.Remove(motion); | ||
130 | } | ||
131 | } | ||
132 | } | ||
133 | |||
134 | [Serializable] | ||
135 | public class KeyframeMotion | ||
136 | { | ||
137 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
138 | |||
139 | public enum PlayMode : int | ||
140 | { | ||
141 | Forward = 0, | ||
142 | Reverse = 1, | ||
143 | Loop = 2, | ||
144 | PingPong = 3 | ||
145 | }; | ||
146 | |||
147 | [Flags] | ||
148 | public enum DataFormat : int | ||
149 | { | ||
150 | Translation = 2, | ||
151 | Rotation = 1 | ||
152 | } | ||
153 | |||
154 | [Serializable] | ||
155 | public struct Keyframe | ||
156 | { | ||
157 | public Vector3? Position; | ||
158 | public Quaternion? Rotation; | ||
159 | public Quaternion StartRotation; | ||
160 | public int TimeMS; | ||
161 | public int TimeTotal; | ||
162 | public Vector3 AngularVelocity; | ||
163 | }; | ||
164 | |||
165 | private Vector3 m_serializedPosition; | ||
166 | private Vector3 m_basePosition; | ||
167 | private Quaternion m_baseRotation; | ||
168 | |||
169 | private Keyframe m_currentFrame; | ||
170 | |||
171 | private List<Keyframe> m_frames = new List<Keyframe>(); | ||
172 | |||
173 | private Keyframe[] m_keyframes; | ||
174 | |||
175 | // skip timer events. | ||
176 | //timer.stop doesn't assure there aren't event threads still being fired | ||
177 | [NonSerialized()] | ||
178 | private bool m_timerStopped; | ||
179 | |||
180 | [NonSerialized()] | ||
181 | private bool m_isCrossing; | ||
182 | |||
183 | [NonSerialized()] | ||
184 | private bool m_waitingCrossing; | ||
185 | |||
186 | // retry position for cross fail | ||
187 | [NonSerialized()] | ||
188 | private Vector3 m_nextPosition; | ||
189 | |||
190 | [NonSerialized()] | ||
191 | private SceneObjectGroup m_group; | ||
192 | |||
193 | private PlayMode m_mode = PlayMode.Forward; | ||
194 | private DataFormat m_data = DataFormat.Translation | DataFormat.Rotation; | ||
195 | |||
196 | private bool m_running = false; | ||
197 | |||
198 | [NonSerialized()] | ||
199 | private bool m_selected = false; | ||
200 | |||
201 | private int m_iterations = 0; | ||
202 | |||
203 | private int m_skipLoops = 0; | ||
204 | |||
205 | [NonSerialized()] | ||
206 | private Scene m_scene; | ||
207 | |||
208 | public Scene Scene | ||
209 | { | ||
210 | get { return m_scene; } | ||
211 | } | ||
212 | |||
213 | public DataFormat Data | ||
214 | { | ||
215 | get { return m_data; } | ||
216 | } | ||
217 | |||
218 | public bool Selected | ||
219 | { | ||
220 | set | ||
221 | { | ||
222 | if (m_group != null) | ||
223 | { | ||
224 | if (!value) | ||
225 | { | ||
226 | // Once we're let go, recompute positions | ||
227 | if (m_selected) | ||
228 | UpdateSceneObject(m_group); | ||
229 | } | ||
230 | else | ||
231 | { | ||
232 | // Save selection position in case we get moved | ||
233 | if (!m_selected) | ||
234 | { | ||
235 | StopTimer(); | ||
236 | m_serializedPosition = m_group.AbsolutePosition; | ||
237 | } | ||
238 | } | ||
239 | } | ||
240 | m_isCrossing = false; | ||
241 | m_waitingCrossing = false; | ||
242 | m_selected = value; | ||
243 | } | ||
244 | } | ||
245 | |||
246 | private void StartTimer() | ||
247 | { | ||
248 | KeyframeTimer.Add(this); | ||
249 | m_timerStopped = false; | ||
250 | } | ||
251 | |||
252 | private void StopTimer() | ||
253 | { | ||
254 | m_timerStopped = true; | ||
255 | KeyframeTimer.Remove(this); | ||
256 | } | ||
257 | |||
258 | public static KeyframeMotion FromData(SceneObjectGroup grp, Byte[] data) | ||
259 | { | ||
260 | KeyframeMotion newMotion = null; | ||
261 | |||
262 | try | ||
263 | { | ||
264 | MemoryStream ms = new MemoryStream(data); | ||
265 | BinaryFormatter fmt = new BinaryFormatter(); | ||
266 | |||
267 | newMotion = (KeyframeMotion)fmt.Deserialize(ms); | ||
268 | |||
269 | newMotion.m_group = grp; | ||
270 | |||
271 | if (grp != null) | ||
272 | { | ||
273 | newMotion.m_scene = grp.Scene; | ||
274 | if (grp.IsSelected) | ||
275 | newMotion.m_selected = true; | ||
276 | } | ||
277 | |||
278 | newMotion.m_timerStopped = false; | ||
279 | newMotion.m_running = true; | ||
280 | newMotion.m_isCrossing = false; | ||
281 | newMotion.m_waitingCrossing = false; | ||
282 | } | ||
283 | catch | ||
284 | { | ||
285 | newMotion = null; | ||
286 | } | ||
287 | |||
288 | return newMotion; | ||
289 | } | ||
290 | |||
291 | public void UpdateSceneObject(SceneObjectGroup grp) | ||
292 | { | ||
293 | m_isCrossing = false; | ||
294 | m_waitingCrossing = false; | ||
295 | StopTimer(); | ||
296 | |||
297 | if (grp == null) | ||
298 | return; | ||
299 | |||
300 | m_group = grp; | ||
301 | m_scene = grp.Scene; | ||
302 | |||
303 | Vector3 grppos = grp.AbsolutePosition; | ||
304 | Vector3 offset = grppos - m_serializedPosition; | ||
305 | // avoid doing it more than once | ||
306 | // current this will happen draging a prim to other region | ||
307 | m_serializedPosition = grppos; | ||
308 | |||
309 | m_basePosition += offset; | ||
310 | m_currentFrame.Position += offset; | ||
311 | |||
312 | m_nextPosition += offset; | ||
313 | |||
314 | for (int i = 0; i < m_frames.Count; i++) | ||
315 | { | ||
316 | Keyframe k = m_frames[i]; | ||
317 | k.Position += offset; | ||
318 | m_frames[i]=k; | ||
319 | } | ||
320 | |||
321 | if (m_running) | ||
322 | Start(); | ||
323 | } | ||
324 | |||
325 | public KeyframeMotion(SceneObjectGroup grp, PlayMode mode, DataFormat data) | ||
326 | { | ||
327 | m_mode = mode; | ||
328 | m_data = data; | ||
329 | |||
330 | m_group = grp; | ||
331 | if (grp != null) | ||
332 | { | ||
333 | m_basePosition = grp.AbsolutePosition; | ||
334 | m_baseRotation = grp.GroupRotation; | ||
335 | m_scene = grp.Scene; | ||
336 | } | ||
337 | |||
338 | m_timerStopped = true; | ||
339 | m_isCrossing = false; | ||
340 | m_waitingCrossing = false; | ||
341 | } | ||
342 | |||
343 | public void SetKeyframes(Keyframe[] frames) | ||
344 | { | ||
345 | m_keyframes = frames; | ||
346 | } | ||
347 | |||
348 | public KeyframeMotion Copy(SceneObjectGroup newgrp) | ||
349 | { | ||
350 | StopTimer(); | ||
351 | |||
352 | KeyframeMotion newmotion = new KeyframeMotion(null, m_mode, m_data); | ||
353 | |||
354 | newmotion.m_group = newgrp; | ||
355 | newmotion.m_scene = newgrp.Scene; | ||
356 | |||
357 | if (m_keyframes != null) | ||
358 | { | ||
359 | newmotion.m_keyframes = new Keyframe[m_keyframes.Length]; | ||
360 | m_keyframes.CopyTo(newmotion.m_keyframes, 0); | ||
361 | } | ||
362 | |||
363 | newmotion.m_frames = new List<Keyframe>(m_frames); | ||
364 | |||
365 | newmotion.m_basePosition = m_basePosition; | ||
366 | newmotion.m_baseRotation = m_baseRotation; | ||
367 | |||
368 | if (m_selected) | ||
369 | newmotion.m_serializedPosition = m_serializedPosition; | ||
370 | else | ||
371 | { | ||
372 | if (m_group != null) | ||
373 | newmotion.m_serializedPosition = m_group.AbsolutePosition; | ||
374 | else | ||
375 | newmotion.m_serializedPosition = m_serializedPosition; | ||
376 | } | ||
377 | |||
378 | newmotion.m_currentFrame = m_currentFrame; | ||
379 | |||
380 | newmotion.m_iterations = m_iterations; | ||
381 | newmotion.m_running = m_running; | ||
382 | |||
383 | if (m_running && !m_waitingCrossing) | ||
384 | StartTimer(); | ||
385 | |||
386 | return newmotion; | ||
387 | } | ||
388 | |||
389 | public void Delete() | ||
390 | { | ||
391 | m_running = false; | ||
392 | StopTimer(); | ||
393 | m_isCrossing = false; | ||
394 | m_waitingCrossing = false; | ||
395 | m_frames.Clear(); | ||
396 | m_keyframes = null; | ||
397 | } | ||
398 | |||
399 | public void Start() | ||
400 | { | ||
401 | m_isCrossing = false; | ||
402 | m_waitingCrossing = false; | ||
403 | if (m_keyframes != null && m_group != null && m_keyframes.Length > 0) | ||
404 | { | ||
405 | StartTimer(); | ||
406 | m_running = true; | ||
407 | } | ||
408 | else | ||
409 | { | ||
410 | m_running = false; | ||
411 | StopTimer(); | ||
412 | } | ||
413 | } | ||
414 | |||
415 | public void Stop() | ||
416 | { | ||
417 | m_running = false; | ||
418 | m_isCrossing = false; | ||
419 | m_waitingCrossing = false; | ||
420 | |||
421 | StopTimer(); | ||
422 | |||
423 | m_basePosition = m_group.AbsolutePosition; | ||
424 | m_baseRotation = m_group.GroupRotation; | ||
425 | |||
426 | m_group.RootPart.Velocity = Vector3.Zero; | ||
427 | m_group.RootPart.AngularVelocity = Vector3.Zero; | ||
428 | m_group.SendGroupRootTerseUpdate(); | ||
429 | // m_group.RootPart.ScheduleTerseUpdate(); | ||
430 | m_frames.Clear(); | ||
431 | } | ||
432 | |||
433 | public void Pause() | ||
434 | { | ||
435 | m_running = false; | ||
436 | StopTimer(); | ||
437 | |||
438 | m_group.RootPart.Velocity = Vector3.Zero; | ||
439 | m_group.RootPart.AngularVelocity = Vector3.Zero; | ||
440 | m_group.SendGroupRootTerseUpdate(); | ||
441 | // m_group.RootPart.ScheduleTerseUpdate(); | ||
442 | |||
443 | } | ||
444 | |||
445 | private void GetNextList() | ||
446 | { | ||
447 | m_frames.Clear(); | ||
448 | Vector3 pos = m_basePosition; | ||
449 | Quaternion rot = m_baseRotation; | ||
450 | |||
451 | if (m_mode == PlayMode.Loop || m_mode == PlayMode.PingPong || m_iterations == 0) | ||
452 | { | ||
453 | int direction = 1; | ||
454 | if (m_mode == PlayMode.Reverse || ((m_mode == PlayMode.PingPong) && ((m_iterations & 1) != 0))) | ||
455 | direction = -1; | ||
456 | |||
457 | int start = 0; | ||
458 | int end = m_keyframes.Length; | ||
459 | |||
460 | if (direction < 0) | ||
461 | { | ||
462 | start = m_keyframes.Length - 1; | ||
463 | end = -1; | ||
464 | } | ||
465 | |||
466 | for (int i = start; i != end ; i += direction) | ||
467 | { | ||
468 | Keyframe k = m_keyframes[i]; | ||
469 | |||
470 | if (k.Position.HasValue) | ||
471 | { | ||
472 | k.Position = (k.Position * direction); | ||
473 | // k.Velocity = (Vector3)k.Position / (k.TimeMS / 1000.0f); | ||
474 | k.Position += pos; | ||
475 | } | ||
476 | else | ||
477 | { | ||
478 | k.Position = pos; | ||
479 | // k.Velocity = Vector3.Zero; | ||
480 | } | ||
481 | |||
482 | k.StartRotation = rot; | ||
483 | if (k.Rotation.HasValue) | ||
484 | { | ||
485 | if (direction == -1) | ||
486 | k.Rotation = Quaternion.Conjugate((Quaternion)k.Rotation); | ||
487 | k.Rotation = rot * k.Rotation; | ||
488 | } | ||
489 | else | ||
490 | { | ||
491 | k.Rotation = rot; | ||
492 | } | ||
493 | |||
494 | /* ang vel not in use for now | ||
495 | |||
496 | float angle = 0; | ||
497 | |||
498 | float aa = k.StartRotation.X * k.StartRotation.X + k.StartRotation.Y * k.StartRotation.Y + k.StartRotation.Z * k.StartRotation.Z + k.StartRotation.W * k.StartRotation.W; | ||
499 | float bb = ((Quaternion)k.Rotation).X * ((Quaternion)k.Rotation).X + ((Quaternion)k.Rotation).Y * ((Quaternion)k.Rotation).Y + ((Quaternion)k.Rotation).Z * ((Quaternion)k.Rotation).Z + ((Quaternion)k.Rotation).W * ((Quaternion)k.Rotation).W; | ||
500 | float aa_bb = aa * bb; | ||
501 | |||
502 | if (aa_bb == 0) | ||
503 | { | ||
504 | angle = 0; | ||
505 | } | ||
506 | else | ||
507 | { | ||
508 | float ab = k.StartRotation.X * ((Quaternion)k.Rotation).X + | ||
509 | k.StartRotation.Y * ((Quaternion)k.Rotation).Y + | ||
510 | k.StartRotation.Z * ((Quaternion)k.Rotation).Z + | ||
511 | k.StartRotation.W * ((Quaternion)k.Rotation).W; | ||
512 | float q = (ab * ab) / aa_bb; | ||
513 | |||
514 | if (q > 1.0f) | ||
515 | { | ||
516 | angle = 0; | ||
517 | } | ||
518 | else | ||
519 | { | ||
520 | angle = (float)Math.Acos(2 * q - 1); | ||
521 | } | ||
522 | } | ||
523 | |||
524 | k.AngularVelocity = (new Vector3(0, 0, 1) * (Quaternion)k.Rotation) * (angle / (k.TimeMS / 1000)); | ||
525 | */ | ||
526 | k.TimeTotal = k.TimeMS; | ||
527 | |||
528 | m_frames.Add(k); | ||
529 | |||
530 | pos = (Vector3)k.Position; | ||
531 | rot = (Quaternion)k.Rotation; | ||
532 | } | ||
533 | |||
534 | m_basePosition = pos; | ||
535 | m_baseRotation = rot; | ||
536 | |||
537 | m_iterations++; | ||
538 | } | ||
539 | } | ||
540 | |||
541 | public void OnTimer(double tickDuration) | ||
542 | { | ||
543 | if (m_skipLoops > 0) | ||
544 | { | ||
545 | m_skipLoops--; | ||
546 | return; | ||
547 | } | ||
548 | |||
549 | if (m_timerStopped) // trap events still in air even after a timer.stop | ||
550 | return; | ||
551 | |||
552 | if (m_group == null) | ||
553 | return; | ||
554 | |||
555 | bool update = false; | ||
556 | |||
557 | if (m_selected) | ||
558 | { | ||
559 | if (m_group.RootPart.Velocity != Vector3.Zero) | ||
560 | { | ||
561 | m_group.RootPart.Velocity = Vector3.Zero; | ||
562 | m_group.SendGroupRootTerseUpdate(); | ||
563 | |||
564 | } | ||
565 | return; | ||
566 | } | ||
567 | |||
568 | if (m_isCrossing) | ||
569 | { | ||
570 | // if crossing and timer running then cross failed | ||
571 | // wait some time then | ||
572 | // retry to set the position that evtually caused the outbound | ||
573 | // if still outside region this will call startCrossing below | ||
574 | m_isCrossing = false; | ||
575 | m_group.AbsolutePosition = m_nextPosition; | ||
576 | if (!m_isCrossing) | ||
577 | { | ||
578 | StopTimer(); | ||
579 | StartTimer(); | ||
580 | } | ||
581 | return; | ||
582 | } | ||
583 | |||
584 | if (m_frames.Count == 0) | ||
585 | { | ||
586 | GetNextList(); | ||
587 | |||
588 | if (m_frames.Count == 0) | ||
589 | { | ||
590 | Stop(); | ||
591 | Scene scene = m_group.Scene; | ||
592 | |||
593 | IScriptModule[] scriptModules = scene.RequestModuleInterfaces<IScriptModule>(); | ||
594 | foreach (IScriptModule m in scriptModules) | ||
595 | { | ||
596 | if (m == null) | ||
597 | continue; | ||
598 | m.PostObjectEvent(m_group.RootPart.UUID, "moving_end", new object[0]); | ||
599 | } | ||
600 | |||
601 | return; | ||
602 | } | ||
603 | |||
604 | m_currentFrame = m_frames[0]; | ||
605 | m_currentFrame.TimeMS += (int)tickDuration; | ||
606 | |||
607 | //force a update on a keyframe transition | ||
608 | update = true; | ||
609 | } | ||
610 | |||
611 | m_currentFrame.TimeMS -= (int)tickDuration; | ||
612 | |||
613 | // Do the frame processing | ||
614 | double steps = (double)m_currentFrame.TimeMS / tickDuration; | ||
615 | |||
616 | if (steps <= 0.0) | ||
617 | { | ||
618 | m_group.RootPart.Velocity = Vector3.Zero; | ||
619 | m_group.RootPart.AngularVelocity = Vector3.Zero; | ||
620 | |||
621 | m_nextPosition = (Vector3)m_currentFrame.Position; | ||
622 | m_group.AbsolutePosition = m_nextPosition; | ||
623 | |||
624 | // we are sending imediate updates, no doing force a extra terseUpdate | ||
625 | // m_group.UpdateGroupRotationR((Quaternion)m_currentFrame.Rotation); | ||
626 | |||
627 | m_group.RootPart.RotationOffset = (Quaternion)m_currentFrame.Rotation; | ||
628 | m_frames.RemoveAt(0); | ||
629 | if (m_frames.Count > 0) | ||
630 | m_currentFrame = m_frames[0]; | ||
631 | |||
632 | update = true; | ||
633 | } | ||
634 | else | ||
635 | { | ||
636 | float complete = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal; | ||
637 | |||
638 | Vector3 v = (Vector3)m_currentFrame.Position - m_group.AbsolutePosition; | ||
639 | Vector3 motionThisFrame = v / (float)steps; | ||
640 | v = v * 1000 / m_currentFrame.TimeMS; | ||
641 | |||
642 | if (Vector3.Mag(motionThisFrame) >= 0.05f) | ||
643 | { | ||
644 | // m_group.AbsolutePosition += motionThisFrame; | ||
645 | m_nextPosition = m_group.AbsolutePosition + motionThisFrame; | ||
646 | m_group.AbsolutePosition = m_nextPosition; | ||
647 | |||
648 | //m_group.RootPart.Velocity = v; | ||
649 | update = true; | ||
650 | } | ||
651 | |||
652 | if ((Quaternion)m_currentFrame.Rotation != m_group.GroupRotation) | ||
653 | { | ||
654 | Quaternion current = m_group.GroupRotation; | ||
655 | |||
656 | Quaternion step = Quaternion.Slerp(m_currentFrame.StartRotation, (Quaternion)m_currentFrame.Rotation, complete); | ||
657 | step.Normalize(); | ||
658 | /* use simpler change detection | ||
659 | * float angle = 0; | ||
660 | |||
661 | float aa = current.X * current.X + current.Y * current.Y + current.Z * current.Z + current.W * current.W; | ||
662 | float bb = step.X * step.X + step.Y * step.Y + step.Z * step.Z + step.W * step.W; | ||
663 | float aa_bb = aa * bb; | ||
664 | |||
665 | if (aa_bb == 0) | ||
666 | { | ||
667 | angle = 0; | ||
668 | } | ||
669 | else | ||
670 | { | ||
671 | float ab = current.X * step.X + | ||
672 | current.Y * step.Y + | ||
673 | current.Z * step.Z + | ||
674 | current.W * step.W; | ||
675 | float q = (ab * ab) / aa_bb; | ||
676 | |||
677 | if (q > 1.0f) | ||
678 | { | ||
679 | angle = 0; | ||
680 | } | ||
681 | else | ||
682 | { | ||
683 | angle = (float)Math.Acos(2 * q - 1); | ||
684 | } | ||
685 | } | ||
686 | |||
687 | if (angle > 0.01f) | ||
688 | */ | ||
689 | if(Math.Abs(step.X - current.X) > 0.001f | ||
690 | || Math.Abs(step.Y - current.Y) > 0.001f | ||
691 | || Math.Abs(step.Z - current.Z) > 0.001f) | ||
692 | // assuming w is a dependente var | ||
693 | |||
694 | { | ||
695 | // m_group.UpdateGroupRotationR(step); | ||
696 | m_group.RootPart.RotationOffset = step; | ||
697 | |||
698 | //m_group.RootPart.UpdateAngularVelocity(m_currentFrame.AngularVelocity / 2); | ||
699 | update = true; | ||
700 | } | ||
701 | } | ||
702 | } | ||
703 | |||
704 | if (update) | ||
705 | { | ||
706 | m_group.SendGroupRootTerseUpdate(); | ||
707 | } | ||
708 | } | ||
709 | |||
710 | public Byte[] Serialize() | ||
711 | { | ||
712 | StopTimer(); | ||
713 | MemoryStream ms = new MemoryStream(); | ||
714 | |||
715 | BinaryFormatter fmt = new BinaryFormatter(); | ||
716 | SceneObjectGroup tmp = m_group; | ||
717 | m_group = null; | ||
718 | if (!m_selected && tmp != null) | ||
719 | m_serializedPosition = tmp.AbsolutePosition; | ||
720 | fmt.Serialize(ms, this); | ||
721 | m_group = tmp; | ||
722 | if (m_running && !m_waitingCrossing) | ||
723 | StartTimer(); | ||
724 | |||
725 | return ms.ToArray(); | ||
726 | } | ||
727 | |||
728 | public void StartCrossingCheck() | ||
729 | { | ||
730 | // timer will be restart by crossingFailure | ||
731 | // or never since crossing worked and this | ||
732 | // should be deleted | ||
733 | StopTimer(); | ||
734 | |||
735 | m_isCrossing = true; | ||
736 | m_waitingCrossing = true; | ||
737 | |||
738 | // to remove / retune to smoth crossings | ||
739 | if (m_group.RootPart.Velocity != Vector3.Zero) | ||
740 | { | ||
741 | m_group.RootPart.Velocity = Vector3.Zero; | ||
742 | m_group.SendGroupRootTerseUpdate(); | ||
743 | // m_group.RootPart.ScheduleTerseUpdate(); | ||
744 | } | ||
745 | } | ||
746 | |||
747 | public void CrossingFailure() | ||
748 | { | ||
749 | m_waitingCrossing = false; | ||
750 | |||
751 | if (m_group != null) | ||
752 | { | ||
753 | m_group.RootPart.Velocity = Vector3.Zero; | ||
754 | m_group.SendGroupRootTerseUpdate(); | ||
755 | // m_group.RootPart.ScheduleTerseUpdate(); | ||
756 | |||
757 | if (m_running) | ||
758 | { | ||
759 | StopTimer(); | ||
760 | m_skipLoops = 1200; // 60 seconds | ||
761 | StartTimer(); | ||
762 | } | ||
763 | } | ||
764 | } | ||
765 | } | ||
766 | } | ||