aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Physics
diff options
context:
space:
mode:
authorRobert Adams2012-12-02 23:39:17 -0800
committerRobert Adams2012-12-03 07:59:56 -0800
commit41f1c5b7f712ed9c093ce421b39460c7711aece4 (patch)
tree7972aaece55d5e174a4e6db552b54156130ab892 /OpenSim/Region/Physics
parentBulletSim: add stubs for generalization of preStep actions. Will eventually r... (diff)
downloadopensim-SC_OLD-41f1c5b7f712ed9c093ce421b39460c7711aece4.zip
opensim-SC_OLD-41f1c5b7f712ed9c093ce421b39460c7711aece4.tar.gz
opensim-SC_OLD-41f1c5b7f712ed9c093ce421b39460c7711aece4.tar.bz2
opensim-SC_OLD-41f1c5b7f712ed9c093ce421b39460c7711aece4.tar.xz
BulletSim: rework angular corrections to remove any hybrid code and compute absolute collections.
Diffstat (limited to 'OpenSim/Region/Physics')
-rw-r--r--OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs204
-rwxr-xr-xOpenSim/Region/Physics/BulletSPlugin/BSMotors.cs17
-rw-r--r--OpenSim/Region/Physics/BulletSPlugin/BSScene.cs4
-rwxr-xr-xOpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt1
4 files changed, 115 insertions, 111 deletions
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
index 4d067cf..525aac4 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
@@ -98,7 +98,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
98 private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate 98 private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate
99 private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate 99 private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate
100 private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate 100 private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate
101 private Vector3 m_lastAngularVelocity = Vector3.Zero; // what was last applied to body 101 private Vector3 m_lastAngularCorrection = Vector3.Zero;
102 private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body 102 private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body
103 103
104 //Deflection properties 104 //Deflection properties
@@ -111,6 +111,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
111 private float m_bankingEfficiency = 0; 111 private float m_bankingEfficiency = 0;
112 private float m_bankingMix = 0; 112 private float m_bankingMix = 0;
113 private float m_bankingTimescale = 0; 113 private float m_bankingTimescale = 0;
114 private Vector3 m_lastBanking = Vector3.Zero;
114 115
115 //Hover and Buoyancy properties 116 //Hover and Buoyancy properties
116 private float m_VhoverHeight = 0f; 117 private float m_VhoverHeight = 0f;
@@ -152,7 +153,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
152 m_angularDeflectionTimescale = Math.Max(pValue, 0.01f); 153 m_angularDeflectionTimescale = Math.Max(pValue, 0.01f);
153 break; 154 break;
154 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: 155 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
155 m_angularMotorDecayTimescale = Math.Max(0.01f, Math.Min(pValue,120)); 156 m_angularMotorDecayTimescale = ClampInRange(0.01f, pValue, 120);
156 m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale; 157 m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale;
157 break; 158 break;
158 case Vehicle.ANGULAR_MOTOR_TIMESCALE: 159 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
@@ -240,9 +241,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
240 break; 241 break;
241 case Vehicle.ANGULAR_MOTOR_DIRECTION: 242 case Vehicle.ANGULAR_MOTOR_DIRECTION:
242 // Limit requested angular speed to 2 rps= 4 pi rads/sec 243 // Limit requested angular speed to 2 rps= 4 pi rads/sec
243 pValue.X = Math.Max(-12.56f, Math.Min(pValue.X, 12.56f)); 244 pValue.X = ClampInRange(-12.56f, pValue.X, 12.56f);
244 pValue.Y = Math.Max(-12.56f, Math.Min(pValue.Y, 12.56f)); 245 pValue.Y = ClampInRange(-12.56f, pValue.Y, 12.56f);
245 pValue.Z = Math.Max(-12.56f, Math.Min(pValue.Z, 12.56f)); 246 pValue.Z = ClampInRange(-12.56f, pValue.Z, 12.56f);
246 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); 247 m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
247 m_angularMotor.SetTarget(m_angularMotorDirection); 248 m_angularMotor.SetTarget(m_angularMotorDirection);
248 break; 249 break;
@@ -328,6 +329,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
328 m_bankingEfficiency = 0; 329 m_bankingEfficiency = 0;
329 m_bankingTimescale = 1000; 330 m_bankingTimescale = 1000;
330 m_bankingMix = 1; 331 m_bankingMix = 1;
332 m_lastBanking = Vector3.Zero;
331 333
332 m_referenceFrame = Quaternion.Identity; 334 m_referenceFrame = Quaternion.Identity;
333 m_flags = (VehicleFlag)0; 335 m_flags = (VehicleFlag)0;
@@ -362,6 +364,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
362 m_bankingEfficiency = 0; 364 m_bankingEfficiency = 0;
363 m_bankingTimescale = 10; 365 m_bankingTimescale = 10;
364 m_bankingMix = 1; 366 m_bankingMix = 1;
367 m_lastBanking = Vector3.Zero;
365 368
366 m_referenceFrame = Quaternion.Identity; 369 m_referenceFrame = Quaternion.Identity;
367 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY 370 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
@@ -400,6 +403,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
400 m_bankingEfficiency = -0.2f; 403 m_bankingEfficiency = -0.2f;
401 m_bankingMix = 1; 404 m_bankingMix = 1;
402 m_bankingTimescale = 1; 405 m_bankingTimescale = 1;
406 m_lastBanking = Vector3.Zero;
403 407
404 m_referenceFrame = Quaternion.Identity; 408 m_referenceFrame = Quaternion.Identity;
405 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY 409 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
@@ -438,6 +442,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
438 m_bankingEfficiency = -0.3f; 442 m_bankingEfficiency = -0.3f;
439 m_bankingMix = 0.8f; 443 m_bankingMix = 0.8f;
440 m_bankingTimescale = 1; 444 m_bankingTimescale = 1;
445 m_lastBanking = Vector3.Zero;
441 446
442 m_referenceFrame = Quaternion.Identity; 447 m_referenceFrame = Quaternion.Identity;
443 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY 448 m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY
@@ -476,6 +481,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
476 m_bankingEfficiency = 1; 481 m_bankingEfficiency = 1;
477 m_bankingMix = 0.7f; 482 m_bankingMix = 0.7f;
478 m_bankingTimescale = 2; 483 m_bankingTimescale = 2;
484 m_lastBanking = Vector3.Zero;
479 485
480 m_referenceFrame = Quaternion.Identity; 486 m_referenceFrame = Quaternion.Identity;
481 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY 487 m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
@@ -514,6 +520,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
514 m_bankingEfficiency = 0; 520 m_bankingEfficiency = 0;
515 m_bankingMix = 0.7f; 521 m_bankingMix = 0.7f;
516 m_bankingTimescale = 5; 522 m_bankingTimescale = 5;
523 m_lastBanking = Vector3.Zero;
524
517 m_referenceFrame = Quaternion.Identity; 525 m_referenceFrame = Quaternion.Identity;
518 526
519 m_referenceFrame = Quaternion.Identity; 527 m_referenceFrame = Quaternion.Identity;
@@ -627,12 +635,16 @@ namespace OpenSim.Region.Physics.BulletSPlugin
627 { 635 {
628 if (m_knownChanged != 0) 636 if (m_knownChanged != 0)
629 { 637 {
630 if ((m_knownChanged & m_knownChangedPosition) != 0) Prim.ForcePosition = VehiclePosition; 638 if ((m_knownChanged & m_knownChangedPosition) != 0)
631 if ((m_knownChanged & m_knownChangedOrientation) != 0) Prim.ForceOrientation = VehicleOrientation; 639 Prim.ForcePosition = VehiclePosition;
632 if ((m_knownChanged & m_knownChangedVelocity) != 0) Prim.ForceVelocity = VehicleVelocity; 640 if ((m_knownChanged & m_knownChangedOrientation) != 0)
633 if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0) Prim.ForceRotationalVelocity = VehicleRotationalVelocity; 641 Prim.ForceOrientation = VehicleOrientation;
634 // If we set one of the values (ie, the physics engine doesn't do it) we must make sure there 642 if ((m_knownChanged & m_knownChangedVelocity) != 0)
635 // is an UpdateProperties event to send the changes up to the simulator. 643 Prim.ForceVelocity = VehicleVelocity;
644 if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0)
645 Prim.ForceRotationalVelocity = VehicleRotationalVelocity;
646 // If we set one of the values (ie, the physics engine didn't do it) we must force
647 // an UpdateProperties event to send the changes up to the simulator.
636 BulletSimAPI.PushUpdate2(Prim.PhysBody.ptr); 648 BulletSimAPI.PushUpdate2(Prim.PhysBody.ptr);
637 } 649 }
638 } 650 }
@@ -957,9 +969,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
957 // ======================================================================= 969 // =======================================================================
958 // ======================================================================= 970 // =======================================================================
959 // Apply the effect of the angular motor. 971 // Apply the effect of the angular motor.
972 // The 'contribution' is how much angular correction each function wants.
973 // All the contributions are added together and the orientation of the vehicle
974 // is changed by all the contributed corrections.
960 private void MoveAngular(float pTimestep) 975 private void MoveAngular(float pTimestep)
961 { 976 {
962 Vector3 angularMotorContribution = m_angularMotor.Step(pTimestep); 977 Vector3 angularMotorContribution = m_angularMotor.Step();
963 978
964 // ================================================================== 979 // ==================================================================
965 // From http://wiki.secondlife.com/wiki/LlSetVehicleFlags : 980 // From http://wiki.secondlife.com/wiki/LlSetVehicleFlags :
@@ -974,22 +989,41 @@ namespace OpenSim.Region.Physics.BulletSPlugin
974 VDetailLog("{0}, MoveAngular,noDeflectionUp,angularMotorContrib={1}", Prim.LocalID, angularMotorContribution); 989 VDetailLog("{0}, MoveAngular,noDeflectionUp,angularMotorContrib={1}", Prim.LocalID, angularMotorContribution);
975 } 990 }
976 991
977 Vector3 verticalAttractionContribution = ComputeAngularVerticalAttraction(pTimestep); 992 Vector3 verticalAttractionContribution = ComputeAngularVerticalAttraction();
978 993
979 Vector3 deflectionContribution = ComputeAngularDeflection(pTimestep); 994 Vector3 deflectionContribution = ComputeAngularDeflection();
980 995
981 Vector3 bankingContribution = ComputeAngularBanking(pTimestep); 996 Vector3 bankingContribution = ComputeAngularBanking(angularMotorContribution.Z);
982 997
983 // ================================================================== 998 // ==================================================================
984 m_lastVertAttractor = verticalAttractionContribution; 999 m_lastVertAttractor = verticalAttractionContribution;
985 1000
986 // Sum velocities 1001 // Sum corrections
987 m_lastAngularVelocity = angularMotorContribution 1002 m_lastAngularCorrection = angularMotorContribution
988 + verticalAttractionContribution 1003 + verticalAttractionContribution
989 + deflectionContribution 1004 + deflectionContribution
990 + bankingContribution; 1005 + bankingContribution;
991 1006
992 // ================================================================== 1007 // ==================================================================
1008 // The correction is applied to the current orientation.
1009 // Any angular velocity on the vehicle is not us so zero the current value.
1010 VehicleRotationalVelocity = Vector3.Zero;
1011 if (!m_lastAngularCorrection.ApproxEquals(Vector3.Zero, 0.01f))
1012 {
1013 Vector3 scaledCorrection = m_lastAngularCorrection * pTimestep;
1014 Quaternion quatCorrection = Quaternion.CreateFromEulers(scaledCorrection);
1015
1016 VehicleOrientation = Quaternion.Add(VehicleOrientation, quatCorrection);
1017
1018 VDetailLog("{0}, MoveAngular,done,nonZero,angMotorContrib={1},vertAttrContrib={2},bankContrib={3},deflectContrib={4},totalContrib={5},scaledCorr={6}",
1019 Prim.LocalID,
1020 angularMotorContribution, verticalAttractionContribution,
1021 bankingContribution, deflectionContribution,
1022 m_lastAngularCorrection, scaledCorrection
1023 );
1024 }
1025
1026 // ==================================================================
993 //Offset section 1027 //Offset section
994 if (m_linearMotorOffset != Vector3.Zero) 1028 if (m_linearMotorOffset != Vector3.Zero)
995 { 1029 {
@@ -1020,50 +1054,18 @@ namespace OpenSim.Region.Physics.BulletSPlugin
1020 VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset); 1054 VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset);
1021 } 1055 }
1022 1056
1023 // ==================================================================
1024 if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f))
1025 {
1026 // TODO: zeroing is good but it also sets values in unmanaged code. Remove the stores when idle.
1027 VDetailLog("{0}, MoveAngular,done,zero", Prim.LocalID);
1028 VehicleRotationalVelocity = Vector3.Zero;
1029 Prim.ZeroAngularMotion(true);
1030 }
1031 else
1032 {
1033 // Apply to the body.
1034 // The above calculates the absolute angular velocity needed. Angular velocity is massless.
1035 // Since we are stuffing the angular velocity directly into the object, the computed
1036 // velocity needs to be scaled by the timestep.
1037 // Also remove any motion that is on the object so added motion is only from vehicle.
1038 Vector3 setAngularVelocity = ((m_lastAngularVelocity * pTimestep) - VehicleRotationalVelocity);
1039 VehicleRotationalVelocity = setAngularVelocity;
1040
1041 VDetailLog("{0}, MoveAngular,done,nonZero,angMotorContrib={1},vertAttrContrib={2},bankContrib={3},deflectContrib={4},totalContrib={5},setAngVelocity={6}",
1042 Prim.LocalID,
1043 angularMotorContribution, verticalAttractionContribution,
1044 bankingContribution, deflectionContribution,
1045 m_lastAngularVelocity, setAngularVelocity
1046 );
1047 }
1048 } 1057 }
1049 1058
1050 public Vector3 ComputeAngularVerticalAttraction(float pTimestep) 1059 public Vector3 ComputeAngularVerticalAttraction()
1051 { 1060 {
1052 Vector3 ret = Vector3.Zero; 1061 Vector3 ret = Vector3.Zero;
1053 1062
1054 // If vertical attaction timescale is reasonable and we applied an angular force last time... 1063 // If vertical attaction timescale is reasonable and we applied an angular force last time...
1055 if (m_verticalAttractionTimescale < 500) 1064 if (m_verticalAttractionTimescale < 500)
1056 { 1065 {
1057 /*
1058 Vector3 verticalError = Vector3.UnitZ * VehicleOrientation;
1059 verticalError.Normalize();
1060 m_verticalAttractionMotor.SetCurrent(verticalError);
1061 m_verticalAttractionMotor.SetTarget(Vector3.UnitZ);
1062 ret = m_verticalAttractionMotor.Step(pTimestep);
1063 */
1064 // Take a vector pointing up and convert it from world to vehicle relative coords. 1066 // Take a vector pointing up and convert it from world to vehicle relative coords.
1065 Vector3 verticalError = Vector3.UnitZ * VehicleOrientation; 1067 Vector3 verticalError = Vector3.UnitZ * VehicleOrientation;
1066 verticalError.Normalize(); 1068 // verticalError.Normalize();
1067 1069
1068 // If vertical attraction correction is needed, the vector that was pointing up (UnitZ) 1070 // If vertical attraction correction is needed, the vector that was pointing up (UnitZ)
1069 // is now leaning to one side (rotated around the X axis) and the Y value will 1071 // is now leaning to one side (rotated around the X axis) and the Y value will
@@ -1087,56 +1089,63 @@ namespace OpenSim.Region.Physics.BulletSPlugin
1087 // scale by the time scale and timestep 1089 // scale by the time scale and timestep
1088 Vector3 unscaledContrib = ret; 1090 Vector3 unscaledContrib = ret;
1089 ret /= m_verticalAttractionTimescale; 1091 ret /= m_verticalAttractionTimescale;
1090 ret *= pTimestep; 1092 // This returns the angular correction desired. Timestep is added later.
1093 // ret *= pTimestep;
1091 1094
1092 // apply efficiency 1095 // apply efficiency
1093 Vector3 preEfficiencyContrib = ret; 1096 Vector3 preEfficiencyContrib = ret;
1097 // TODO: implement efficiency.
1094 // Effenciency squared seems to give a more realistic effect 1098 // Effenciency squared seems to give a more realistic effect
1095 float efficencySquared = m_verticalAttractionEfficiency * m_verticalAttractionEfficiency; 1099 float efficencySquared = m_verticalAttractionEfficiency * m_verticalAttractionEfficiency;
1096 ret *= efficencySquared; 1100 // ret *= efficencySquared;
1097 1101
1098 VDetailLog("{0}, MoveAngular,verticalAttraction,,verticalError={1},unscaled={2},preEff={3},eff={4},effSq={5},vertAttr={6}", 1102 VDetailLog("{0}, MoveAngular,verticalAttraction,,verticalError={1},unscaled={2},preEff={3},eff={4},effSq={5},vertAttr={6}",
1099 Prim.LocalID, verticalError, unscaledContrib, preEfficiencyContrib, 1103 Prim.LocalID, verticalError, unscaledContrib, preEfficiencyContrib,
1100 m_verticalAttractionEfficiency, efficencySquared, 1104 m_verticalAttractionEfficiency, efficencySquared,
1101 ret); 1105 ret);
1102
1103 } 1106 }
1104 return ret; 1107 return ret;
1105 } 1108 }
1106 1109
1107 public Vector3 ComputeAngularDeflection(float pTimestep) 1110 // Return the angular correction to correct the direction the vehicle is pointing to be
1111 // the direction is should want to be pointing.
1112 public Vector3 ComputeAngularDeflection()
1108 { 1113 {
1109 Vector3 ret = Vector3.Zero; 1114 Vector3 ret = Vector3.Zero;
1110 1115
1111 if (m_angularDeflectionEfficiency != 0) 1116 if (m_angularDeflectionEfficiency != 0)
1112 { 1117 {
1113 // Compute a scaled vector that points in the preferred axis (X direction) 1118 // Where the vehicle should want to point relative to the vehicle
1114 Vector3 scaledDefaultDirection = 1119 Vector3 preferredDirection = Vector3.UnitX * m_referenceFrame;
1115 new Vector3((pTimestep * 10 * (m_angularDeflectionEfficiency / m_angularDeflectionTimescale)), 0, 0); 1120
1116 // Adding the current vehicle orientation and reference frame displaces the orientation to the frame. 1121 // Where the vehicle is pointing relative to the vehicle.
1117 // Rotate the scaled default axix relative to the actual vehicle direction giving where it should point. 1122 Vector3 currentDirection = Vector3.UnitX * Quaternion.Add(VehicleOrientation, m_referenceFrame);
1118 Vector3 preferredAxisOfMotion = scaledDefaultDirection * Quaternion.Add(VehicleOrientation, m_referenceFrame);
1119 1123
1120 // Scale by efficiency and timescale 1124 // Difference between where vehicle is pointing and where it should wish to point
1121 ret = (preferredAxisOfMotion * (m_angularDeflectionEfficiency) / m_angularDeflectionTimescale) * pTimestep; 1125 Vector3 directionCorrection = preferredDirection - currentDirection;
1122 1126
1123 VDetailLog("{0}, MoveAngular,Deflection,perfAxis={1},deflection={2}", Prim.LocalID, preferredAxisOfMotion, ret); 1127 // Scale the correction by recovery timescale and efficiency
1128 ret = directionCorrection * m_angularDeflectionEfficiency / m_angularDeflectionTimescale;
1124 1129
1125 // This deflection computation is not correct. 1130 VDetailLog("{0}, MoveAngular,Deflection,perfDir={1},currentDir={2},dirCorrection={3},ret={4}",
1126 ret = Vector3.Zero; 1131 Prim.LocalID, preferredDirection, currentDirection, directionCorrection, ret);
1127 } 1132 }
1128 return ret; 1133 return ret;
1129 } 1134 }
1130 1135
1131 public Vector3 ComputeAngularBanking(float pTimestep) 1136 // Return an angular change to tip the vehicle (around X axis) when turning (turned around Z).
1137 // Remembers the last banking value calculated and returns the difference needed this tick.
1138 // TurningFactor is rate going left or right (pos=left, neg=right, scale=0..1).
1139 public Vector3 ComputeAngularBanking(float turningFactor)
1132 { 1140 {
1133 Vector3 ret = Vector3.Zero; 1141 Vector3 ret = Vector3.Zero;
1142 Vector3 computedBanking = Vector3.Zero;
1134 1143
1135 if (m_bankingEfficiency != 0) 1144 if (m_bankingEfficiency != 0)
1136 { 1145 {
1137 Vector3 dir = Vector3.One * VehicleOrientation; 1146 Vector3 currentDirection = Vector3.UnitX * VehicleOrientation;
1147
1138 float mult = (m_bankingMix * m_bankingMix) * -1 * (m_bankingMix < 0 ? -1 : 1); 1148 float mult = (m_bankingMix * m_bankingMix) * -1 * (m_bankingMix < 0 ? -1 : 1);
1139 //Changes which way it banks in and out of turns
1140 1149
1141 //Use the square of the efficiency, as it looks much more how SL banking works 1150 //Use the square of the efficiency, as it looks much more how SL banking works
1142 float effSquared = (m_bankingEfficiency * m_bankingEfficiency); 1151 float effSquared = (m_bankingEfficiency * m_bankingEfficiency);
@@ -1144,51 +1153,27 @@ namespace OpenSim.Region.Physics.BulletSPlugin
1144 effSquared *= -1; //Keep the negative! 1153 effSquared *= -1; //Keep the negative!
1145 1154
1146 float mix = Math.Abs(m_bankingMix); 1155 float mix = Math.Abs(m_bankingMix);
1147 if (m_angularMotorVelocity.X == 0) 1156 // TODO: Must include reference frame.
1148 { 1157 float forwardSpeed = VehicleVelocity.X;
1149 // The vehicle is stopped
1150 /*if (!parent.Orientation.ApproxEquals(this.m_referenceFrame, 0.25f))
1151 {
1152 Vector3 axisAngle;
1153 float angle;
1154 parent.Orientation.GetAxisAngle(out axisAngle, out angle);
1155 Vector3 rotatedVel = parent.Velocity * parent.Orientation;
1156 if ((rotatedVel.X < 0 && axisAngle.Y > 0) || (rotatedVel.X > 0 && axisAngle.Y < 0))
1157 m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (1f) * 10;
1158 else
1159 m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (-1f) * 10;
1160 }*/
1161 }
1162 else
1163 {
1164 ret.Z += (effSquared * (mult * mix)) * (m_angularMotorVelocity.X) * 4;
1165 }
1166 1158
1167 //If they are colliding, we probably shouldn't shove the prim around... probably 1159 if (!Prim.IsColliding && forwardSpeed > mix)
1168 if (!Prim.IsColliding && Math.Abs(m_angularMotorVelocity.X) > mix)
1169 { 1160 {
1170 float angVelZ = m_angularMotorVelocity.X * -1; 1161 computedBanking.X = ClampInRange(-3f, turningFactor * (effSquared * mult), 3f);
1171 /*if(angVelZ > mix)
1172 angVelZ = mix;
1173 else if(angVelZ < -mix)
1174 angVelZ = -mix;*/
1175 //This controls how fast and how far the banking occurs
1176 Vector3 bankingRot = new Vector3(angVelZ * (effSquared * mult), 0, 0);
1177 if (bankingRot.X > 3)
1178 bankingRot.X = 3;
1179 else if (bankingRot.X < -3)
1180 bankingRot.X = -3;
1181 bankingRot *= VehicleOrientation;
1182 ret += bankingRot;
1183 } 1162 }
1184 m_angularMotorVelocity.X *= m_bankingEfficiency == 1 ? 0.0f : 1 - m_bankingEfficiency; 1163
1185 VDetailLog("{0}, MoveAngular,Banking,bEff={1},angMotVel={2},effSq={3},mult={4},mix={5},banking={6}", 1164 // 'computedBanking' is now how much banking that should be happening.
1186 Prim.LocalID, m_bankingEfficiency, m_angularMotorVelocity, effSquared, mult, mix, ret); 1165 ret = computedBanking - m_lastBanking;
1166
1167 // Scale the correction by timescale and efficiency
1168 ret /= m_bankingTimescale * m_bankingEfficiency;
1169
1170 VDetailLog("{0}, MoveAngular,Banking,computedB={1},lastB={2},bEff={3},effSq={4},mult={5},mix={6},banking={7}",
1171 Prim.LocalID, computedBanking, m_lastBanking, m_bankingEfficiency, effSquared, mult, mix, ret);
1187 } 1172 }
1173 m_lastBanking = computedBanking;
1188 return ret; 1174 return ret;
1189 } 1175 }
1190 1176
1191
1192 // This is from previous instantiations of XXXDynamics.cs. 1177 // This is from previous instantiations of XXXDynamics.cs.
1193 // Applies roll reference frame. 1178 // Applies roll reference frame.
1194 // TODO: is this the right way to separate the code to do this operation? 1179 // TODO: is this the right way to separate the code to do this operation?
@@ -1229,6 +1214,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
1229 1214
1230 } 1215 }
1231 1216
1217 private float ClampInRange(float low, float val, float high)
1218 {
1219 return Math.Max(low, Math.Min(val, high));
1220 }
1221
1232 // Invoke the detailed logger and output something if it's enabled. 1222 // Invoke the detailed logger and output something if it's enabled.
1233 private void VDetailLog(string msg, params Object[] args) 1223 private void VDetailLog(string msg, params Object[] args)
1234 { 1224 {
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
index e9f1549..851d508 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
@@ -63,10 +63,23 @@ public abstract class BSMotor
63 } 63 }
64} 64}
65// Can all the incremental stepping be replaced with motor classes? 65// Can all the incremental stepping be replaced with motor classes?
66
67// Motor which moves CurrentValue to TargetValue over TimeScale seconds.
68// The TargetValue is decays in TargetValueDecayTimeScale and
69// the CurrentValue will be held back by FrictionTimeScale.
70// TimeScale and TargetDelayTimeScale may be 'infinite' which means go decay.
71
72// For instance, if something is moving at speed X and the desired speed is Y,
73// CurrentValue is X and TargetValue is Y. As the motor is stepped, new
74// values of CurrentValue are returned that approach the TargetValue.
75// The feature of decaying TargetValue is so vehicles will eventually
76// come to a stop rather than run forever. This can be disabled by
77// setting TargetValueDecayTimescale to 'infinite'.
78// The change from CurrentValue to TargetValue is linear over TimeScale seconds.
66public class BSVMotor : BSMotor 79public class BSVMotor : BSMotor
67{ 80{
68 public Vector3 FrameOfReference { get; set; } 81 // public Vector3 FrameOfReference { get; set; }
69 public Vector3 Offset { get; set; } 82 // public Vector3 Offset { get; set; }
70 83
71 public float TimeScale { get; set; } 84 public float TimeScale { get; set; }
72 public float TargetValueDecayTimeScale { get; set; } 85 public float TargetValueDecayTimeScale { get; set; }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index 17cc7b4..f72bd74 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -501,7 +501,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
501 501
502 try 502 try
503 { 503 {
504 // if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG 504 if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG
505 if (PhysicsLogging.Enabled) beforeTime = Util.EnvironmentTickCount(); 505 if (PhysicsLogging.Enabled) beforeTime = Util.EnvironmentTickCount();
506 506
507 numSubSteps = BulletSimAPI.PhysicsStep2(World.ptr, timeStep, m_maxSubSteps, m_fixedTimeStep, 507 numSubSteps = BulletSimAPI.PhysicsStep2(World.ptr, timeStep, m_maxSubSteps, m_fixedTimeStep,
@@ -510,7 +510,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
510 if (PhysicsLogging.Enabled) simTime = Util.EnvironmentTickCountSubtract(beforeTime); 510 if (PhysicsLogging.Enabled) simTime = Util.EnvironmentTickCountSubtract(beforeTime);
511 DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}", 511 DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}",
512 DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps, updatedEntityCount, collidersCount); 512 DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps, updatedEntityCount, collidersCount);
513 // if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG 513 if (VehicleLoggingEnabled) DumpVehicles(); // DEBUG
514 } 514 }
515 catch (Exception e) 515 catch (Exception e)
516 { 516 {
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt b/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
index ca71313..68f25fc 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
@@ -28,6 +28,7 @@ Small physical objects do not interact correctly
28Add material type linkage and input all the material property definitions. 28Add material type linkage and input all the material property definitions.
29 Skeleton classes and table are in the sources but are not filled or used. 29 Skeleton classes and table are in the sources but are not filled or used.
30Add PID motor for avatar movement (slow to stop, ...) 30Add PID motor for avatar movement (slow to stop, ...)
31Implement function efficiency for lineaar and angular motion.
31 32
32After getting off a vehicle, the root prim is phantom (can be walked through) 33After getting off a vehicle, the root prim is phantom (can be walked through)
33 Need to force a position update for the root prim after compound shape destruction 34 Need to force a position update for the root prim after compound shape destruction