Committing Avination's Keyframe module. This is not hooked up yet and will do nothing. More commits to follow.
Melanie
parent
26cd59cd6f
commit
e1d98c9e4c
|
|
@ -0,0 +1,766 @@
|
|||
// Proprietary code of Avination Virtual Limited
|
||||
// (c) 2012 Melanie Thielker
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Timers;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Diagnostics;
|
||||
using System.Reflection;
|
||||
using System.Threading;
|
||||
using OpenMetaverse;
|
||||
using OpenSim.Framework;
|
||||
using OpenSim.Region.Framework.Interfaces;
|
||||
using OpenSim.Region.Physics.Manager;
|
||||
using OpenSim.Region.Framework.Scenes.Serialization;
|
||||
using System.Runtime.Serialization.Formatters.Binary;
|
||||
using System.Runtime.Serialization;
|
||||
using Timer = System.Timers.Timer;
|
||||
using log4net;
|
||||
|
||||
namespace OpenSim.Region.Framework.Scenes
|
||||
{
|
||||
public class KeyframeTimer
|
||||
{
|
||||
private static Dictionary<Scene, KeyframeTimer>m_timers =
|
||||
new Dictionary<Scene, KeyframeTimer>();
|
||||
|
||||
private Timer m_timer;
|
||||
private Dictionary<KeyframeMotion, object> m_motions = new Dictionary<KeyframeMotion, object>();
|
||||
private object m_lockObject = new object();
|
||||
private object m_timerLock = new object();
|
||||
private const double m_tickDuration = 50.0;
|
||||
private Scene m_scene;
|
||||
|
||||
public double TickDuration
|
||||
{
|
||||
get { return m_tickDuration; }
|
||||
}
|
||||
|
||||
public KeyframeTimer(Scene scene)
|
||||
{
|
||||
m_timer = new Timer();
|
||||
m_timer.Interval = TickDuration;
|
||||
m_timer.AutoReset = true;
|
||||
m_timer.Elapsed += OnTimer;
|
||||
|
||||
m_scene = scene;
|
||||
|
||||
m_timer.Start();
|
||||
}
|
||||
|
||||
private void OnTimer(object sender, ElapsedEventArgs ea)
|
||||
{
|
||||
if (!Monitor.TryEnter(m_timerLock))
|
||||
return;
|
||||
|
||||
try
|
||||
{
|
||||
List<KeyframeMotion> motions;
|
||||
|
||||
lock (m_lockObject)
|
||||
{
|
||||
motions = new List<KeyframeMotion>(m_motions.Keys);
|
||||
}
|
||||
|
||||
foreach (KeyframeMotion m in motions)
|
||||
{
|
||||
try
|
||||
{
|
||||
m.OnTimer(TickDuration);
|
||||
}
|
||||
catch (Exception inner)
|
||||
{
|
||||
// Don't stop processing
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
// Keep running no matter what
|
||||
}
|
||||
finally
|
||||
{
|
||||
Monitor.Exit(m_timerLock);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Add(KeyframeMotion motion)
|
||||
{
|
||||
KeyframeTimer timer;
|
||||
|
||||
if (motion.Scene == null)
|
||||
return;
|
||||
|
||||
lock (m_timers)
|
||||
{
|
||||
if (!m_timers.TryGetValue(motion.Scene, out timer))
|
||||
{
|
||||
timer = new KeyframeTimer(motion.Scene);
|
||||
m_timers[motion.Scene] = timer;
|
||||
}
|
||||
}
|
||||
|
||||
lock (timer.m_lockObject)
|
||||
{
|
||||
timer.m_motions[motion] = null;
|
||||
}
|
||||
}
|
||||
|
||||
public static void Remove(KeyframeMotion motion)
|
||||
{
|
||||
KeyframeTimer timer;
|
||||
|
||||
if (motion.Scene == null)
|
||||
return;
|
||||
|
||||
lock (m_timers)
|
||||
{
|
||||
if (!m_timers.TryGetValue(motion.Scene, out timer))
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
lock (timer.m_lockObject)
|
||||
{
|
||||
timer.m_motions.Remove(motion);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Serializable]
|
||||
public class KeyframeMotion
|
||||
{
|
||||
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
||||
|
||||
public enum PlayMode : int
|
||||
{
|
||||
Forward = 0,
|
||||
Reverse = 1,
|
||||
Loop = 2,
|
||||
PingPong = 3
|
||||
};
|
||||
|
||||
[Flags]
|
||||
public enum DataFormat : int
|
||||
{
|
||||
Translation = 2,
|
||||
Rotation = 1
|
||||
}
|
||||
|
||||
[Serializable]
|
||||
public struct Keyframe
|
||||
{
|
||||
public Vector3? Position;
|
||||
public Quaternion? Rotation;
|
||||
public Quaternion StartRotation;
|
||||
public int TimeMS;
|
||||
public int TimeTotal;
|
||||
public Vector3 AngularVelocity;
|
||||
};
|
||||
|
||||
private Vector3 m_serializedPosition;
|
||||
private Vector3 m_basePosition;
|
||||
private Quaternion m_baseRotation;
|
||||
|
||||
private Keyframe m_currentFrame;
|
||||
|
||||
private List<Keyframe> m_frames = new List<Keyframe>();
|
||||
|
||||
private Keyframe[] m_keyframes;
|
||||
|
||||
// skip timer events.
|
||||
//timer.stop doesn't assure there aren't event threads still being fired
|
||||
[NonSerialized()]
|
||||
private bool m_timerStopped;
|
||||
|
||||
[NonSerialized()]
|
||||
private bool m_isCrossing;
|
||||
|
||||
[NonSerialized()]
|
||||
private bool m_waitingCrossing;
|
||||
|
||||
// retry position for cross fail
|
||||
[NonSerialized()]
|
||||
private Vector3 m_nextPosition;
|
||||
|
||||
[NonSerialized()]
|
||||
private SceneObjectGroup m_group;
|
||||
|
||||
private PlayMode m_mode = PlayMode.Forward;
|
||||
private DataFormat m_data = DataFormat.Translation | DataFormat.Rotation;
|
||||
|
||||
private bool m_running = false;
|
||||
|
||||
[NonSerialized()]
|
||||
private bool m_selected = false;
|
||||
|
||||
private int m_iterations = 0;
|
||||
|
||||
private int m_skipLoops = 0;
|
||||
|
||||
[NonSerialized()]
|
||||
private Scene m_scene;
|
||||
|
||||
public Scene Scene
|
||||
{
|
||||
get { return m_scene; }
|
||||
}
|
||||
|
||||
public DataFormat Data
|
||||
{
|
||||
get { return m_data; }
|
||||
}
|
||||
|
||||
public bool Selected
|
||||
{
|
||||
set
|
||||
{
|
||||
if (m_group != null)
|
||||
{
|
||||
if (!value)
|
||||
{
|
||||
// Once we're let go, recompute positions
|
||||
if (m_selected)
|
||||
UpdateSceneObject(m_group);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Save selection position in case we get moved
|
||||
if (!m_selected)
|
||||
{
|
||||
StopTimer();
|
||||
m_serializedPosition = m_group.AbsolutePosition;
|
||||
}
|
||||
}
|
||||
}
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
m_selected = value;
|
||||
}
|
||||
}
|
||||
|
||||
private void StartTimer()
|
||||
{
|
||||
KeyframeTimer.Add(this);
|
||||
m_timerStopped = false;
|
||||
}
|
||||
|
||||
private void StopTimer()
|
||||
{
|
||||
m_timerStopped = true;
|
||||
KeyframeTimer.Remove(this);
|
||||
}
|
||||
|
||||
public static KeyframeMotion FromData(SceneObjectGroup grp, Byte[] data)
|
||||
{
|
||||
KeyframeMotion newMotion = null;
|
||||
|
||||
try
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(data);
|
||||
BinaryFormatter fmt = new BinaryFormatter();
|
||||
|
||||
newMotion = (KeyframeMotion)fmt.Deserialize(ms);
|
||||
|
||||
newMotion.m_group = grp;
|
||||
|
||||
if (grp != null)
|
||||
{
|
||||
newMotion.m_scene = grp.Scene;
|
||||
if (grp.IsSelected)
|
||||
newMotion.m_selected = true;
|
||||
}
|
||||
|
||||
newMotion.m_timerStopped = false;
|
||||
newMotion.m_running = true;
|
||||
newMotion.m_isCrossing = false;
|
||||
newMotion.m_waitingCrossing = false;
|
||||
}
|
||||
catch
|
||||
{
|
||||
newMotion = null;
|
||||
}
|
||||
|
||||
return newMotion;
|
||||
}
|
||||
|
||||
public void UpdateSceneObject(SceneObjectGroup grp)
|
||||
{
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
StopTimer();
|
||||
|
||||
if (grp == null)
|
||||
return;
|
||||
|
||||
m_group = grp;
|
||||
m_scene = grp.Scene;
|
||||
|
||||
Vector3 grppos = grp.AbsolutePosition;
|
||||
Vector3 offset = grppos - m_serializedPosition;
|
||||
// avoid doing it more than once
|
||||
// current this will happen draging a prim to other region
|
||||
m_serializedPosition = grppos;
|
||||
|
||||
m_basePosition += offset;
|
||||
m_currentFrame.Position += offset;
|
||||
|
||||
m_nextPosition += offset;
|
||||
|
||||
for (int i = 0; i < m_frames.Count; i++)
|
||||
{
|
||||
Keyframe k = m_frames[i];
|
||||
k.Position += offset;
|
||||
m_frames[i]=k;
|
||||
}
|
||||
|
||||
if (m_running)
|
||||
Start();
|
||||
}
|
||||
|
||||
public KeyframeMotion(SceneObjectGroup grp, PlayMode mode, DataFormat data)
|
||||
{
|
||||
m_mode = mode;
|
||||
m_data = data;
|
||||
|
||||
m_group = grp;
|
||||
if (grp != null)
|
||||
{
|
||||
m_basePosition = grp.AbsolutePosition;
|
||||
m_baseRotation = grp.GroupRotation;
|
||||
m_scene = grp.Scene;
|
||||
}
|
||||
|
||||
m_timerStopped = true;
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
}
|
||||
|
||||
public void SetKeyframes(Keyframe[] frames)
|
||||
{
|
||||
m_keyframes = frames;
|
||||
}
|
||||
|
||||
public KeyframeMotion Copy(SceneObjectGroup newgrp)
|
||||
{
|
||||
StopTimer();
|
||||
|
||||
KeyframeMotion newmotion = new KeyframeMotion(null, m_mode, m_data);
|
||||
|
||||
newmotion.m_group = newgrp;
|
||||
newmotion.m_scene = newgrp.Scene;
|
||||
|
||||
if (m_keyframes != null)
|
||||
{
|
||||
newmotion.m_keyframes = new Keyframe[m_keyframes.Length];
|
||||
m_keyframes.CopyTo(newmotion.m_keyframes, 0);
|
||||
}
|
||||
|
||||
newmotion.m_frames = new List<Keyframe>(m_frames);
|
||||
|
||||
newmotion.m_basePosition = m_basePosition;
|
||||
newmotion.m_baseRotation = m_baseRotation;
|
||||
|
||||
if (m_selected)
|
||||
newmotion.m_serializedPosition = m_serializedPosition;
|
||||
else
|
||||
{
|
||||
if (m_group != null)
|
||||
newmotion.m_serializedPosition = m_group.AbsolutePosition;
|
||||
else
|
||||
newmotion.m_serializedPosition = m_serializedPosition;
|
||||
}
|
||||
|
||||
newmotion.m_currentFrame = m_currentFrame;
|
||||
|
||||
newmotion.m_iterations = m_iterations;
|
||||
newmotion.m_running = m_running;
|
||||
|
||||
if (m_running && !m_waitingCrossing)
|
||||
StartTimer();
|
||||
|
||||
return newmotion;
|
||||
}
|
||||
|
||||
public void Delete()
|
||||
{
|
||||
m_running = false;
|
||||
StopTimer();
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
m_frames.Clear();
|
||||
m_keyframes = null;
|
||||
}
|
||||
|
||||
public void Start()
|
||||
{
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
if (m_keyframes != null && m_group != null && m_keyframes.Length > 0)
|
||||
{
|
||||
StartTimer();
|
||||
m_running = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_running = false;
|
||||
StopTimer();
|
||||
}
|
||||
}
|
||||
|
||||
public void Stop()
|
||||
{
|
||||
m_running = false;
|
||||
m_isCrossing = false;
|
||||
m_waitingCrossing = false;
|
||||
|
||||
StopTimer();
|
||||
|
||||
m_basePosition = m_group.AbsolutePosition;
|
||||
m_baseRotation = m_group.GroupRotation;
|
||||
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.RootPart.AngularVelocity = Vector3.Zero;
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
// m_group.RootPart.ScheduleTerseUpdate();
|
||||
m_frames.Clear();
|
||||
}
|
||||
|
||||
public void Pause()
|
||||
{
|
||||
m_running = false;
|
||||
StopTimer();
|
||||
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.RootPart.AngularVelocity = Vector3.Zero;
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
// m_group.RootPart.ScheduleTerseUpdate();
|
||||
|
||||
}
|
||||
|
||||
private void GetNextList()
|
||||
{
|
||||
m_frames.Clear();
|
||||
Vector3 pos = m_basePosition;
|
||||
Quaternion rot = m_baseRotation;
|
||||
|
||||
if (m_mode == PlayMode.Loop || m_mode == PlayMode.PingPong || m_iterations == 0)
|
||||
{
|
||||
int direction = 1;
|
||||
if (m_mode == PlayMode.Reverse || ((m_mode == PlayMode.PingPong) && ((m_iterations & 1) != 0)))
|
||||
direction = -1;
|
||||
|
||||
int start = 0;
|
||||
int end = m_keyframes.Length;
|
||||
|
||||
if (direction < 0)
|
||||
{
|
||||
start = m_keyframes.Length - 1;
|
||||
end = -1;
|
||||
}
|
||||
|
||||
for (int i = start; i != end ; i += direction)
|
||||
{
|
||||
Keyframe k = m_keyframes[i];
|
||||
|
||||
if (k.Position.HasValue)
|
||||
{
|
||||
k.Position = (k.Position * direction);
|
||||
// k.Velocity = (Vector3)k.Position / (k.TimeMS / 1000.0f);
|
||||
k.Position += pos;
|
||||
}
|
||||
else
|
||||
{
|
||||
k.Position = pos;
|
||||
// k.Velocity = Vector3.Zero;
|
||||
}
|
||||
|
||||
k.StartRotation = rot;
|
||||
if (k.Rotation.HasValue)
|
||||
{
|
||||
if (direction == -1)
|
||||
k.Rotation = Quaternion.Conjugate((Quaternion)k.Rotation);
|
||||
k.Rotation = rot * k.Rotation;
|
||||
}
|
||||
else
|
||||
{
|
||||
k.Rotation = rot;
|
||||
}
|
||||
|
||||
/* ang vel not in use for now
|
||||
|
||||
float angle = 0;
|
||||
|
||||
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;
|
||||
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;
|
||||
float aa_bb = aa * bb;
|
||||
|
||||
if (aa_bb == 0)
|
||||
{
|
||||
angle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
float ab = k.StartRotation.X * ((Quaternion)k.Rotation).X +
|
||||
k.StartRotation.Y * ((Quaternion)k.Rotation).Y +
|
||||
k.StartRotation.Z * ((Quaternion)k.Rotation).Z +
|
||||
k.StartRotation.W * ((Quaternion)k.Rotation).W;
|
||||
float q = (ab * ab) / aa_bb;
|
||||
|
||||
if (q > 1.0f)
|
||||
{
|
||||
angle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
angle = (float)Math.Acos(2 * q - 1);
|
||||
}
|
||||
}
|
||||
|
||||
k.AngularVelocity = (new Vector3(0, 0, 1) * (Quaternion)k.Rotation) * (angle / (k.TimeMS / 1000));
|
||||
*/
|
||||
k.TimeTotal = k.TimeMS;
|
||||
|
||||
m_frames.Add(k);
|
||||
|
||||
pos = (Vector3)k.Position;
|
||||
rot = (Quaternion)k.Rotation;
|
||||
}
|
||||
|
||||
m_basePosition = pos;
|
||||
m_baseRotation = rot;
|
||||
|
||||
m_iterations++;
|
||||
}
|
||||
}
|
||||
|
||||
public void OnTimer(double tickDuration)
|
||||
{
|
||||
if (m_skipLoops > 0)
|
||||
{
|
||||
m_skipLoops--;
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_timerStopped) // trap events still in air even after a timer.stop
|
||||
return;
|
||||
|
||||
if (m_group == null)
|
||||
return;
|
||||
|
||||
bool update = false;
|
||||
|
||||
if (m_selected)
|
||||
{
|
||||
if (m_group.RootPart.Velocity != Vector3.Zero)
|
||||
{
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_isCrossing)
|
||||
{
|
||||
// if crossing and timer running then cross failed
|
||||
// wait some time then
|
||||
// retry to set the position that evtually caused the outbound
|
||||
// if still outside region this will call startCrossing below
|
||||
m_isCrossing = false;
|
||||
m_group.AbsolutePosition = m_nextPosition;
|
||||
if (!m_isCrossing)
|
||||
{
|
||||
StopTimer();
|
||||
StartTimer();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_frames.Count == 0)
|
||||
{
|
||||
GetNextList();
|
||||
|
||||
if (m_frames.Count == 0)
|
||||
{
|
||||
Stop();
|
||||
Scene scene = m_group.Scene;
|
||||
|
||||
IScriptModule[] scriptModules = scene.RequestModuleInterfaces<IScriptModule>();
|
||||
foreach (IScriptModule m in scriptModules)
|
||||
{
|
||||
if (m == null)
|
||||
continue;
|
||||
m.PostObjectEvent(m_group.RootPart.UUID, "moving_end", new object[0]);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
m_currentFrame = m_frames[0];
|
||||
m_currentFrame.TimeMS += (int)tickDuration;
|
||||
|
||||
//force a update on a keyframe transition
|
||||
update = true;
|
||||
}
|
||||
|
||||
m_currentFrame.TimeMS -= (int)tickDuration;
|
||||
|
||||
// Do the frame processing
|
||||
double steps = (double)m_currentFrame.TimeMS / tickDuration;
|
||||
|
||||
if (steps <= 0.0)
|
||||
{
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.RootPart.AngularVelocity = Vector3.Zero;
|
||||
|
||||
m_nextPosition = (Vector3)m_currentFrame.Position;
|
||||
m_group.AbsolutePosition = m_nextPosition;
|
||||
|
||||
// we are sending imediate updates, no doing force a extra terseUpdate
|
||||
// m_group.UpdateGroupRotationR((Quaternion)m_currentFrame.Rotation);
|
||||
|
||||
m_group.RootPart.RotationOffset = (Quaternion)m_currentFrame.Rotation;
|
||||
m_frames.RemoveAt(0);
|
||||
if (m_frames.Count > 0)
|
||||
m_currentFrame = m_frames[0];
|
||||
|
||||
update = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
float complete = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal;
|
||||
|
||||
Vector3 v = (Vector3)m_currentFrame.Position - m_group.AbsolutePosition;
|
||||
Vector3 motionThisFrame = v / (float)steps;
|
||||
v = v * 1000 / m_currentFrame.TimeMS;
|
||||
|
||||
if (Vector3.Mag(motionThisFrame) >= 0.05f)
|
||||
{
|
||||
// m_group.AbsolutePosition += motionThisFrame;
|
||||
m_nextPosition = m_group.AbsolutePosition + motionThisFrame;
|
||||
m_group.AbsolutePosition = m_nextPosition;
|
||||
|
||||
//m_group.RootPart.Velocity = v;
|
||||
update = true;
|
||||
}
|
||||
|
||||
if ((Quaternion)m_currentFrame.Rotation != m_group.GroupRotation)
|
||||
{
|
||||
Quaternion current = m_group.GroupRotation;
|
||||
|
||||
Quaternion step = Quaternion.Slerp(m_currentFrame.StartRotation, (Quaternion)m_currentFrame.Rotation, complete);
|
||||
step.Normalize();
|
||||
/* use simpler change detection
|
||||
* float angle = 0;
|
||||
|
||||
float aa = current.X * current.X + current.Y * current.Y + current.Z * current.Z + current.W * current.W;
|
||||
float bb = step.X * step.X + step.Y * step.Y + step.Z * step.Z + step.W * step.W;
|
||||
float aa_bb = aa * bb;
|
||||
|
||||
if (aa_bb == 0)
|
||||
{
|
||||
angle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
float ab = current.X * step.X +
|
||||
current.Y * step.Y +
|
||||
current.Z * step.Z +
|
||||
current.W * step.W;
|
||||
float q = (ab * ab) / aa_bb;
|
||||
|
||||
if (q > 1.0f)
|
||||
{
|
||||
angle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
angle = (float)Math.Acos(2 * q - 1);
|
||||
}
|
||||
}
|
||||
|
||||
if (angle > 0.01f)
|
||||
*/
|
||||
if(Math.Abs(step.X - current.X) > 0.001f
|
||||
|| Math.Abs(step.Y - current.Y) > 0.001f
|
||||
|| Math.Abs(step.Z - current.Z) > 0.001f)
|
||||
// assuming w is a dependente var
|
||||
|
||||
{
|
||||
// m_group.UpdateGroupRotationR(step);
|
||||
m_group.RootPart.RotationOffset = step;
|
||||
|
||||
//m_group.RootPart.UpdateAngularVelocity(m_currentFrame.AngularVelocity / 2);
|
||||
update = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (update)
|
||||
{
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
public Byte[] Serialize()
|
||||
{
|
||||
StopTimer();
|
||||
MemoryStream ms = new MemoryStream();
|
||||
|
||||
BinaryFormatter fmt = new BinaryFormatter();
|
||||
SceneObjectGroup tmp = m_group;
|
||||
m_group = null;
|
||||
if (!m_selected && tmp != null)
|
||||
m_serializedPosition = tmp.AbsolutePosition;
|
||||
fmt.Serialize(ms, this);
|
||||
m_group = tmp;
|
||||
if (m_running && !m_waitingCrossing)
|
||||
StartTimer();
|
||||
|
||||
return ms.ToArray();
|
||||
}
|
||||
|
||||
public void StartCrossingCheck()
|
||||
{
|
||||
// timer will be restart by crossingFailure
|
||||
// or never since crossing worked and this
|
||||
// should be deleted
|
||||
StopTimer();
|
||||
|
||||
m_isCrossing = true;
|
||||
m_waitingCrossing = true;
|
||||
|
||||
// to remove / retune to smoth crossings
|
||||
if (m_group.RootPart.Velocity != Vector3.Zero)
|
||||
{
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
// m_group.RootPart.ScheduleTerseUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
public void CrossingFailure()
|
||||
{
|
||||
m_waitingCrossing = false;
|
||||
|
||||
if (m_group != null)
|
||||
{
|
||||
m_group.RootPart.Velocity = Vector3.Zero;
|
||||
m_group.SendGroupRootTerseUpdate();
|
||||
// m_group.RootPart.ScheduleTerseUpdate();
|
||||
|
||||
if (m_running)
|
||||
{
|
||||
StopTimer();
|
||||
m_skipLoops = 1200; // 60 seconds
|
||||
StartTimer();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue