OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

using System;
using System.Collections.Generic;
using System.Text;
using OpenMetaverse;

namespace OpenSim.Region.Physics.BulletSPlugin
{
public abstract class BSMotor
{
    public virtual void Reset() { }
    public virtual void Zero() { }
}
// Can all the incremental stepping be replaced with motor classes?
public class BSVMotor : BSMotor
{
    public Vector3 FrameOfReference { get; set; }
    public Vector3 Offset { get; set; }

    public float TimeScale { get; set; }
    public float TargetValueDecayTimeScale { get; set; }
    public Vector3 CurrentValueReductionTimescale { get; set; }
    public float Efficiency { get; set; }

    public Vector3 TargetValue { get; private set; }
    public Vector3 CurrentValue { get; private set; }


    BSVMotor(float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency)
    {
        TimeScale = timeScale;
        TargetValueDecayTimeScale = decayTimeScale;
        CurrentValueReductionTimescale = frictionTimeScale;
        Efficiency = efficiency;
    }
    public void SetCurrent(Vector3 current)
    {
        CurrentValue = current;
    }
    public void SetTarget(Vector3 target)
    {
        TargetValue = target;
    }
    public Vector3 Step(float timeStep)
    {
        if (CurrentValue.LengthSquared() > 0.001f)
        {
            // Vector3 origDir = Target;       // DEBUG
            // Vector3 origVel = CurrentValue;   // DEBUG

            // Add (desiredVelocity - currentAppliedVelocity) / howLongItShouldTakeToComplete
            Vector3 addAmount = (TargetValue - CurrentValue)/(TargetValue) * timeStep;
            CurrentValue += addAmount;

            float decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
            TargetValue *= (1f - decayFactor);

            Vector3 frictionFactor = (Vector3.One / CurrentValueReductionTimescale) * timeStep;
            CurrentValue *= (Vector3.One - frictionFactor);
        }
        else
        {
            // if what remains of direction is very small, zero it.
            TargetValue = Vector3.Zero;
            CurrentValue = Vector3.Zero;

            // VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID);
        }
        return CurrentValue;
    }
}

public class BSFMotor : BSMotor
{
    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)
    {
    }
    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()
    {
    }
}
}