1 files changed, 129 insertions, 104 deletions
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
index bc6e4c4..b8bdd87 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
@@ -1,104 +1,129 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Text;
+using System.Text;
-using OpenMetaverse;
+using OpenMetaverse;
-namespace OpenSim.Region.Physics.BulletSPlugin
+namespace OpenSim.Region.Physics.BulletSPlugin
-{
+{
-public abstract class BSMotor
+public abstract class BSMotor
-{
+{
-    public virtual void Reset() { }
+    public BSMotor()
-    public virtual void Zero() { }
+    {
-}
+        PhysicsScene = null;
-// Can all the incremental stepping be replaced with motor classes?
+    }
-public class BSVMotor : BSMotor
+    public virtual void Reset() { }
-{
+    public virtual void Zero() { }
-    public Vector3 FrameOfReference { get; set; }
-    public Vector3 Offset { get; set; }
+    // Used only for outputting debug information. Might not be set so check for null.
+    public BSScene PhysicsScene { get; set; }
-    public float TimeScale { get; set; }
+    protected void MDetailLog(string msg, params Object[] parms)
-    public float TargetValueDecayTimeScale { get; set; }
+    {
-    public Vector3 CurrentValueReductionTimescale { get; set; }
+        if (PhysicsScene != null)
-    public float Efficiency { get; set; }
+        {
+            if (PhysicsScene.VehicleLoggingEnabled)
-    public Vector3 TargetValue { get; private set; }
+            {
-    public Vector3 CurrentValue { get; private set; }
+                PhysicsScene.DetailLog(msg, parms);
+            }
+        }
+    }
-    BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency)
+}
-    {
+// Can all the incremental stepping be replaced with motor classes?
-        TimeScale = timeScale;
+public class BSVMotor : BSMotor
-        TargetValueDecayTimeScale = decayTimeScale;
+{
-        CurrentValueReductionTimescale = frictionTimeScale;
+    public Vector3 FrameOfReference { get; set; }
-        Efficiency = efficiency;
+    public Vector3 Offset { get; set; }
-    }
-    public void SetCurrent(Vector3 current)
+    public float TimeScale { get; set; }
-    {
+    public float TargetValueDecayTimeScale { get; set; }
-        CurrentValue = current;
+    public Vector3 CurrentValueReductionTimescale { get; set; }
-    }
+    public float Efficiency { get; set; }
-    public void SetTarget(Vector3 target)
-    {
+    public Vector3 TargetValue { get; private set; }
-        TargetValue = target;
+    public Vector3 CurrentValue { get; private set; }
-    }
-    public Vector3 Step(float timeStep)
+    BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency) : base()
-    {
+    {
-        if (CurrentValue.LengthSquared() > 0.001f)
+        TimeScale = timeScale;
-        {
+        TargetValueDecayTimeScale = decayTimeScale;
-            // Vector3 origDir = Target;       // DEBUG
+        CurrentValueReductionTimescale = frictionTimeScale;
-            // Vector3 origVel = CurrentValue;   // DEBUG
+        Efficiency = efficiency;
+        CurrentValue = TargetValue = Vector3.Zero;
-            // Add (desiredVelocity - currentAppliedVelocity) / howLongItShouldTakeToComplete
+    }
-            Vector3 addAmount = (TargetValue - CurrentValue)/(TargetValue) * timeStep;
+    public void SetCurrent(Vector3 current)
-            CurrentValue += addAmount;
+    {
+        CurrentValue = current;
-            float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
+    }
-            TargetValue *= (1f - decayFactor);
+    public void SetTarget(Vector3 target)
+    {
-            Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep;
+        TargetValue = target;
-            CurrentValue *= (Vector3.One - frictionFactor);
+    }
-        }
+    public Vector3 Step(float timeStep)
-        else
+    {
-        {
+        Vector3 returnCurrent = Vector3.Zero;
-            // if what remains of direction is very small, zero it.
+        if (CurrentValue.LengthSquared() > 0.001f)
-            TargetValue = Vector3.Zero;
+        {
-            CurrentValue = Vector3.Zero;
+            // Vector3 origDir = Target;       // DEBUG
+            // Vector3 origVel = CurrentValue;   // DEBUG
-            // VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID);
-        }
+            // Add (desiredVector - currentAppliedVector) / howLongItShouldTakeToComplete
-        return CurrentValue;
+            Vector3 addAmount = (TargetValue - CurrentValue)/TimeScale * timeStep;
-    }
+            CurrentValue += addAmount;
-}
+            returnCurrent = CurrentValue;
-public class BSFMotor : BSMotor
+            // The desired value reduces to zero when also reduces the difference with current.
-{
+            float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
-    public float TimeScale { get; set; }
+            TargetValue *= (1f - decayFactor);
-    public float DecayTimeScale { get; set; }
-    public float Friction { get; set; }
+            Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep;
-    public float Efficiency { get; set; }
+            CurrentValue *= (Vector3.One - frictionFactor);
-    public float Target { get; private set; }
+            MDetailLog("{0},BSVMotor.Step,nonZero,curr={1},target={2},add={3},decay={4},frict={5},ret={6}",
-    public float CurrentValue { get; private set; }
+                                    BSScene.DetailLogZero, TargetValue, CurrentValue, 
+                                    addAmount, decayFactor, frictionFactor, returnCurrent);
-    BSFMotor(float timeScale, float decayTimescale, float friction, float efficiency)
+        }
-    {
+        else
-    }
+        {
-    public void SetCurrent(float target)
+            // Difference between what we have and target is small. Motor is done.
-    {
+            CurrentValue = Vector3.Zero;
-    }
+            TargetValue = Vector3.Zero;
-    public void SetTarget(float target)
-    {
+            MDetailLog("{0},BSVMotor.Step,zero,curr={1},target={2},ret={3}",
-    }
+                                    BSScene.DetailLogZero, TargetValue, CurrentValue, returnCurrent);
-    public float Step(float timeStep)
-    {
+        }
-        return 0f;
+        return returnCurrent;
-    }
+    }
-}
+}
-public class BSPIDMotor : BSMotor
-{
+public class BSFMotor : BSMotor
-    // TODO: write and use this one
+{
-    BSPIDMotor()
+    public float TimeScale { get; set; }
-    {
+    public float DecayTimeScale { get; set; }
-    }
+    public float Friction { get; set; }
-}
+    public float Efficiency { get; set; }
-}
+    public float Target { get; private set; }
+    public float CurrentValue { get; private set; }
+    BSFMotor(float timeScale, float decayTimescale, float friction, float efficiency) : base()
+    {
+    }
+    public void SetCurrent(float target)
+    {
+    }
+    public void SetTarget(float target)
+    {
+    }
+    public float Step(float timeStep)
+    {
+        return 0f;
+    }
+}
+public class BSPIDMotor : BSMotor
+{
+    // TODO: write and use this one
+    BSPIDMotor() : base()
+    {
+    }
+}
+}

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs index bc6e4c4..b8bdd87 100755 --- a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs +++ b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
@@ -1,104 +1,129 @@
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.Text;	3	using System.Text;
4	using OpenMetaverse;	4	using OpenMetaverse;
5		5
6	namespace OpenSim.Region.Physics.BulletSPlugin	6	namespace OpenSim.Region.Physics.BulletSPlugin
7	{	7	{
8	public abstract class BSMotor	8	public abstract class BSMotor
9	{	9	{
10	public virtual void Reset() { }	10	public BSMotor()
11	public virtual void Zero() { }	11	{
12	}	12	PhysicsScene = null;
13	// Can all the incremental stepping be replaced with motor classes?	13	}
14	public class BSVMotor : BSMotor	14	public virtual void Reset() { }
15	{	15	public virtual void Zero() { }
16	public Vector3 FrameOfReference { get; set; }	16
17	public Vector3 Offset { get; set; }	17	// Used only for outputting debug information. Might not be set so check for null.
18		18	public BSScene PhysicsScene { get; set; }
19	public float TimeScale { get; set; }	19	protected void MDetailLog(string msg, params Object[] parms)
20	public float TargetValueDecayTimeScale { get; set; }	20	{
21	public Vector3 CurrentValueReductionTimescale { get; set; }	21	if (PhysicsScene != null)
22	public float Efficiency { get; set; }	22	{
23		23	if (PhysicsScene.VehicleLoggingEnabled)
24	public Vector3 TargetValue { get; private set; }	24	{
25	public Vector3 CurrentValue { get; private set; }	25	PhysicsScene.DetailLog(msg, parms);
26		26	}
27		27	}
28		28	}
29	BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency)	29	}
30	{	30	// Can all the incremental stepping be replaced with motor classes?
31	TimeScale = timeScale;	31	public class BSVMotor : BSMotor
32	TargetValueDecayTimeScale = decayTimeScale;	32	{
33	CurrentValueReductionTimescale = frictionTimeScale;	33	public Vector3 FrameOfReference { get; set; }
34	Efficiency = efficiency;	34	public Vector3 Offset { get; set; }
35	}	35
36	public void SetCurrent(Vector3 current)	36	public float TimeScale { get; set; }
37	{	37	public float TargetValueDecayTimeScale { get; set; }
38	CurrentValue = current;	38	public Vector3 CurrentValueReductionTimescale { get; set; }
39	}	39	public float Efficiency { get; set; }
40	public void SetTarget(Vector3 target)	40
41	{	41	public Vector3 TargetValue { get; private set; }
42	TargetValue = target;	42	public Vector3 CurrentValue { get; private set; }
43	}	43
44	public Vector3 Step(float timeStep)	44	BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency) : base()
45	{	45	{
46	if (CurrentValue.LengthSquared() > 0.001f)	46	TimeScale = timeScale;
47	{	47	TargetValueDecayTimeScale = decayTimeScale;
48	// Vector3 origDir = Target; // DEBUG	48	CurrentValueReductionTimescale = frictionTimeScale;
49	// Vector3 origVel = CurrentValue; // DEBUG	49	Efficiency = efficiency;
50		50	CurrentValue = TargetValue = Vector3.Zero;
51	// Add (desiredVelocity - currentAppliedVelocity) / howLongItShouldTakeToComplete	51	}
52	Vector3 addAmount = (TargetValue - CurrentValue)/(TargetValue) * timeStep;	52	public void SetCurrent(Vector3 current)
53	CurrentValue += addAmount;	53	{
54		54	CurrentValue = current;
55	float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;	55	}
56	TargetValue *= (1f - decayFactor);	56	public void SetTarget(Vector3 target)
57		57	{
58	Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep;	58	TargetValue = target;
59	CurrentValue *= (Vector3.One - frictionFactor);	59	}
60	}	60	public Vector3 Step(float timeStep)
61	else	61	{
62	{	62	Vector3 returnCurrent = Vector3.Zero;
63	// if what remains of direction is very small, zero it.	63	if (CurrentValue.LengthSquared() > 0.001f)
64	TargetValue = Vector3.Zero;	64	{
65	CurrentValue = Vector3.Zero;	65	// Vector3 origDir = Target; // DEBUG
66		66	// Vector3 origVel = CurrentValue; // DEBUG
67	// VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID);	67
68	}	68	// Add (desiredVector - currentAppliedVector) / howLongItShouldTakeToComplete
69	return CurrentValue;	69	Vector3 addAmount = (TargetValue - CurrentValue)/TimeScale * timeStep;
70	}	70	CurrentValue += addAmount;
71	}	71	returnCurrent = CurrentValue;
72		72
73	public class BSFMotor : BSMotor	73	// The desired value reduces to zero when also reduces the difference with current.
74	{	74	float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
75	public float TimeScale { get; set; }	75	TargetValue *= (1f - decayFactor);
76	public float DecayTimeScale { get; set; }	76
77	public float Friction { get; set; }	77	Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep;
78	public float Efficiency { get; set; }	78	CurrentValue *= (Vector3.One - frictionFactor);
79		79
80	public float Target { get; private set; }	80	MDetailLog("{0},BSVMotor.Step,nonZero,curr={1},target={2},add={3},decay={4},frict={5},ret={6}",
81	public float CurrentValue { get; private set; }	81	BSScene.DetailLogZero, TargetValue, CurrentValue,
82		82	addAmount, decayFactor, frictionFactor, returnCurrent);
83	BSFMotor(float timeScale, float decayTimescale, float friction, float efficiency)	83	}
84	{	84	else
85	}	85	{
86	public void SetCurrent(float target)	86	// Difference between what we have and target is small. Motor is done.
87	{	87	CurrentValue = Vector3.Zero;
88	}	88	TargetValue = Vector3.Zero;
89	public void SetTarget(float target)	89
90	{	90	MDetailLog("{0},BSVMotor.Step,zero,curr={1},target={2},ret={3}",
91	}	91	BSScene.DetailLogZero, TargetValue, CurrentValue, returnCurrent);
92	public float Step(float timeStep)	92
93	{	93	}
94	return 0f;	94	return returnCurrent;
95	}	95	}
96	}	96	}
97	public class BSPIDMotor : BSMotor	97
98	{	98	public class BSFMotor : BSMotor
99	// TODO: write and use this one	99	{
100	BSPIDMotor()	100	public float TimeScale { get; set; }
101	{	101	public float DecayTimeScale { get; set; }
102	}	102	public float Friction { get; set; }
103	}	103	public float Efficiency { get; set; }
104	}	104
		105	public float Target { get; private set; }
		106	public float CurrentValue { get; private set; }
		107
		108	BSFMotor(float timeScale, float decayTimescale, float friction, float efficiency) : base()
		109	{
		110	}
		111	public void SetCurrent(float target)
		112	{
		113	}
		114	public void SetTarget(float target)
		115	{
		116	}
		117	public float Step(float timeStep)
		118	{
		119	return 0f;
		120	}
		121	}
		122	public class BSPIDMotor : BSMotor
		123	{
		124	// TODO: write and use this one
		125	BSPIDMotor() : base()
		126	{
		127	}
		128	}
		129	}