public AddForceCmd(PhysicsActor actor, OpenMetaverse.Vector3 force, OpenMetaverse.Vector3 forceOffset, ForceType type)
{
Actor = actor;
Force = force;
Type = type;
ForceOffset = forceOffset;
}
/// <summary>
/// Initialize the class
/// </summary>
/// <param name="baseVehicle">Target vehicle</param>
/// <param name="dropInterval">Interval between flares</param>
/// <param name="maxDropTime">Max time to drop flares</param>
/// <param name="dropOffset">Spawn offset relative to base vehicle</param>
/// <param name="forceType">The type of directional force to apply on spawn</param>
/// <param name="forceMultiplier">Force multiplier</param>
public IRFlareSequence(Vehicle baseVehicle, int dropInterval, int maxDropTime, Vector3 dropOffset, ForceType forceType, float forceMultiplier)
{
this.baseVehicle = baseVehicle;
this.dropInterval = dropInterval;
this.maxDropTime = maxDropTime;
this.dropOffset = dropOffset;
this.forceType = forceType;
this.forceMultiplier = forceMultiplier;
}
private int parseForceType(ForceType type)
{
switch (type)
{
case ForceType.Graviton:
return(1);
case ForceType.Fluxion:
return(2);
case ForceType.Electron:
return(3);
default:
return(0);
}
}
public void setProduction(int type)
{
switch (type)
{
case 0:
production = ForceType.Graviton;
break;
case 1:
production = ForceType.Electron;
break;
case 2:
production = ForceType.Fluxion;
break;
}
}
// velocity does not matter if forcetype != gravity
public Vector3 Apply(ForceType type, Vector3 position, Vector3 velocity)
{
Vector3 force;
switch (type)
{
case ForceType.SimpleAttractor:
force = applySimpleAttractor(position);
break;
case ForceType.SimpleRepeller:
force = applySimpleRepeller(position);
break;
case ForceType.Gravity:
force = applyGravity(position);
break;
case ForceType.Electric:
force = applyElectric(position);
break;
case ForceType.Vortex:
force = applyVortex(position, VortexType.Forward);
break;
case ForceType.Airflow:
force = applyAirFlow(position);
break;
default:
force = applySimpleAttractor(position);
break;
}
if (type == ForceType.Gravity)
{
velocity += force; //visualise acceleration
}
else
{
velocity = force; //visualise velocity
}
return(velocity);
}
public ForceEventArgs(nfloat force)
{
Force = force;
// TODO Tweak these numbers
if (force > 5)
{
Type = ForceType.Strong;
}
else if (force > 3)
{
Type = ForceType.Medium;
}
else
{
Type = ForceType.Weak;
}
}
/// <summary>
/// Creates a new force instance given a template.
/// </summary>
/// <param name="createOnCompleteEvent">If set to <c>true</c> create an onComplete event. This is set to true
/// by default. This parameter is set to false when the Force is created inside a ForceEvent instance. In this
/// case, creating an 'onComplete' Event would cause infinite recursion. This is because each ForceEvent holds
/// an instance of a Force, which creates a new 'Brawler.Event'. Then, the Brawler.Event creates a new ForceEvent,
/// which then creates a new Force, and the recursion never stops. Therefore, if this Force is a member variable
/// inside a ForceEvent instance, the onComplete event should not be created.
/// </param>
public Force(Force template, bool createOnCompleteEvent)
{
if (createOnCompleteEvent)
{
// Create a deep copy of the event
onCompleteEvent = new Brawler.Event(template.onCompleteEvent);
}
// Copy the templates values into this new instance
forceType = template.forceType;
velocity = template.velocity;
relativeToFacingDirection = template.relativeToFacingDirection;
target = template.target;
customTargetPosition = template.customTargetPosition;
faceTarget = template.faceTarget;
startTime = template.startTime;
duration = template.duration;
}
public void setType(ForceType type)
{
this.type = type;
switch (type)
{
case ForceType.Graviton:
this.GetComponent <SpriteRenderer> ().sprite = gravSprite;
break;
case ForceType.Fluxion:
this.GetComponent <SpriteRenderer> ().sprite = fluxSprite;
break;
case ForceType.Electron:
this.GetComponent <SpriteRenderer> ().sprite = elecSprite;
break;
}
}
public void ApplyForceRelative(Vector3 direction, Vector3 rotation = new Vector3(), ForceType forceType = 3)
{
InputArgument[] arguments = new InputArgument[14];
arguments[0] = base.Handle;
arguments[1] = forceType;
arguments[2] = direction.X;
arguments[3] = direction.Y;
arguments[4] = direction.Z;
arguments[5] = rotation.X;
arguments[6] = rotation.Y;
arguments[7] = rotation.Z;
arguments[8] = false;
arguments[9] = true;
arguments[10] = true;
arguments[11] = true;
arguments[12] = false;
arguments[13] = true;
Function.Call(Hash.APPLY_FORCE_TO_ENTITY, arguments);
}
public FramePointResult GetMaximumForce(string ComboName, ForceType ForceType)
{
FramePointResult result = new FramePointResult();
double MaxForce = double.NegativeInfinity;
List <FramePointResult> FrameResults = GetFrameForceList(ComboName, ForceType);
for (int i = 0; i < FrameResults.Count; i++)
{
if (FrameResults[i].ResultValue >= MaxForce)
{
MaxForce = FrameResults[i].ResultValue;
result.ResultValue = MaxForce;
result.Station = FrameResults[i].Station;
}
}
return(result);
}
public FramePointResult GetMinimumForce(string ComboName, ForceType ForceType, StationType StationType)
{
FramePointResult result = new FramePointResult();
List <FramePointResult> FrameResults = GetFrameForceList(ComboName, ForceType);
switch (StationType)
{
case StationType.First:
var MinStation = FrameResults.Select(p => p.Station).Min();
result = GetMinimumForce(ComboName, ForceType, MinStation);
break;
case StationType.Last:
var MaxStation = FrameResults.Select(p => p.Station).Max();
result = GetMinimumForce(ComboName, ForceType, MaxStation);
break;
}
return(result);
}
public void AddForce(Vector3 force, ForceType type)
{
switch (type)
{
case ForceType.Force:
ApplyForce(force);
break;
case ForceType.Acceleration:
ApplyAcceleration(force);
break;
case ForceType.Impulse:
ApplyForceImpulse(force);
break;
case ForceType.Velocity:
ApplyVelocity(force);
break;
}
}
// Set forcetype
private void Update()
{
if (force < 0)
{
forceType = ForceType.ATTRACTION;
}
else if (force > 0)
{
forceType = ForceType.REPULSION;
}
else if (force == 0)
{
forceType = ForceType.NONE;
}
if (force > maxForce)
{
force = maxForce;
}
if (force < minForce)
{
force = minForce;
}
}
private ChMatrixDynamic <double> Qf = new ChMatrixDynamic <double>(); //< Lagrangian force
public ChForce()
{
Body = null;
vpoint = new ChVector(0, 0, 0);
vrelpoint = new ChVector(0, 0, 0);
force = new ChVector(0, 0, 0);
relforce = new ChVector(0, 0, 0);
vdir = ChVector.VECT_X;
vreldir = ChVector.VECT_X;
restpos = new ChVector(0, 0, 0);
mforce = 0;
align = AlignmentFrame.BODY_DIR;
frame = ReferenceFrame.BODY;
mode = ForceType.FORCE;
Qf = new ChMatrixDynamic <double>(7, 1);
modula = new ChFunction_Const(1);
move_x = new ChFunction_Const(0);
move_y = new ChFunction_Const(0);
move_z = new ChFunction_Const(0);
f_x = new ChFunction_Const(0);
f_y = new ChFunction_Const(0);
f_z = new ChFunction_Const(0);
}
public void LancerBoule(ForceType force, Manche manche, int quilleMax = 9, int numeroTour = 1)
{
Tour tour = new Tour();
manche.Tours.Add(tour);
int qteQuilleTombee = CalculQuilleTombee(force, manche, quilleMax);
if (qteQuilleTombee == quilleMax) // c'est un strike ou un spare
{
StrikeOuSpare(manche);
}
else
{
manche.Points += qteQuilleTombee;
if (numeroTour == 1)
{
LancerBoule(force, manche, quilleMax - qteQuilleTombee, 2);
}
}
tour.NbrDeTour = numeroTour;
tour.QuilleTombee = qteQuilleTombee;
tour.QuilleRestantes = quilleMax;
}
private void DoJumping()
{
_lastForceType = ForceType.AfterFlyJump;
_moveState = ZombieMoveState.Jumping;
OnStateChanged();
_rigidBody.constraints = RigidbodyConstraints.None | RigidbodyConstraints.FreezeRotation;
Vector3 rotation = new Vector3(75, _transform.rotation.y, _transform.rotation.z);
Vector3 force = new Vector3(0, _config.physics.afterFlyJumpForce, 0);
_rigidBody.AddForce(force, ForceMode.Impulse);
_animationQueue.Clear();
Sequence seq = DOTween.Sequence();
seq.Append(_transform.DORotate(rotation, _config.physics.afterFlyJumpRotationLength));
// _animationQueue.Add(_animationObjPool.GetZombieJump(seq));
List <object> parameters = new List <object>();
parameters.Add(seq);
_animationQueue.Add(_animationObjPool.GetZombieAnimation(AnimationObjectType.ZombieJump, parameters));
_animationQueue.PlayNext();
}
internal void AddForce(OpenMetaverse.Vector3 force, ForceType ftype)
{
var phyActor = PhysicsActor;
if (phyActor != null)
{
phyActor.AddForce(force, ftype);
}
}
extern private static void ICall_PhysicsBodyComponent_AddForce(PhysicsBodyComponent self, ref Vector3 force, ForceType forcetype, bool bWakeUp);
public override void AddAngularForce(Vector3 force, ForceType ftype)
{
}
private void DeactiveOrDestroy(string sn, ForceType force = ForceType.NO_FORCE)
{
bool isCache = true;
GameObject sc = m_Dict[sn];
SSController ct = sc.GetComponentInChildren<SSController>();
// Set Event
if (ct != null)
{
if (ct.OnDeactive != null) ct.OnDeactive(ct);
}
sc.SetActive(false);
if (ct != null)
{
isCache = ct.IsCache;
}
if (force != ForceType.FORCE_NO_DESTROY)
{
if (!isCache || force == ForceType.FORCE_DESTROY)
{
m_Dict.Remove(sn);
OnSceneUnload (sc);
Destroy(sc);
}
}
}
public abstract void AddAngularForce(OpenMetaverse.Vector3 force, ForceType ftype);
public void SetForceId(ForceType forceType)
{
NetSimAgent.Instance.EntityPublisherSetForceId(entityPublisherPtr, forceType);
}
public override void AddForce(OpenMetaverse.Vector3 force, ForceType ftype)
{
_scene.QueueCommand(new Commands.AddForceCmd(this, force, OpenMetaverse.Vector3.Zero, ftype));
}
/// <summary>
///
/// </summary>
/// <param name="force"></param>
/// <param name="conPt">the contact point of the force, relative to the pre-rotated object. (so, conPt is POST-ROTATED!!!)</param>
/// <param name="type"></param>
public Force(Vector2 force, Vector2 conPt, ForceType type)
{
f = force;
t = type;
con = conPt;
}
public override void AddForceSync(Vector3 Force, Vector3 forceOffset, ForceType type)
{
// TODO Maybe
}
/// <summary>
/// Initialize the class
/// </summary>
/// <param name="baseVehicle">Target vehicle</param>
/// <param name="dropInterval">Interval between flares</param>
/// <param name="maxDropTime">Max time to drop flares</param>
/// <param name="dropOffset">Spawn offset relative to base vehicle</param>
/// <param name="forceType">The type of directional force to apply on spawn</param>
/// <param name="forceMultiplier">Force multiplier</param>
public IRFlareSequence(Vehicle baseVehicle, int dropInterval, int maxDropTime, Vector3 dropOffset, ForceType forceType, float forceMultiplier)
{
this.baseVehicle = baseVehicle;
this.dropInterval = dropInterval;
this.maxDropTime = maxDropTime;
this.dropOffset = dropOffset;
this.forceType = forceType;
this.forceMultiplier = forceMultiplier;
}
public extern static void SendCreateEntitySetData(IntPtr exConnPtr, EntityId senderId, EntityId recieverId, int requestId, EntityType entityType, XYZ location, ForceType ForceType, double psi, double theta, double phi);
private static extern void ICall_PhysicsBodyComponent_AddLocalForceAtPos(PhysicsBodyComponent self, ref Vector3 force, ref Vector3 pos, ForceType forcetype, bool bWakeUp);
private static extern void ICall_PhysicsBodyComponent_AddForce(PhysicsBodyComponent self,ref Vector3 force, ForceType forcetype, bool bWakeUp);
/// <summary>
/// 添加力
/// </summary>
/// <param name="force">力</param>
/// <param name="forcetype">力的类型</param>
/// <param name="bWakeUp">是否唤醒Actor</param>
public void AddForce(Vector3 force, ForceType forcetype, bool bWakeUp)
{
ICall_PhysicsBodyComponent_AddForce(this, ref force, forcetype, bWakeUp);
}
public static void SendForce( ForceType Type, bool IsPlayer1 )
{
Dictionary<ForceType, EffectObject> forces;
if ( IsPlayer1 )
forces = P1Forces;
else
forces = P2Forces;
if ( forces == null )
return;
if ( !forces.ContainsKey( Type ) )
return;
EffectObject force = forces[Type];
force.Start( 1 );
}
public Force(Vector2 force, ForceType type)
: this(force, Vector2.Zero, type)
{
}
public override void AddAngularForce(OpenMetaverse.Vector3 force, ForceType ftype)
{
}
public override void AddForce(Vector3 force, ForceType ftype)
{
AddForceSync(force, OpenMetaverse.Vector3.Zero, ftype);
}
public override void AddForce(Vector3 force, ForceType ftype)
{
AddForceSync(force, OpenMetaverse.Vector3.Zero, ftype);
}
public override void AddForceSync(Vector3 Force, Vector3 forceOffset, ForceType type)
{
Force /= _mass;
switch (type)
{
case ForceType.ConstantLocalLinearForce:
_cForcesAreLocal = true;
_cForces = Force;
break;
case ForceType.ConstantGlobalLinearForce:
_cForcesAreLocal = false;
_cForces = Force;
break;
case ForceType.GlobalLinearImpulse:
_vForces += Force;
break;
case ForceType.LocalLinearImpulse:
_vForces += Force * _rotation;
break;
}
}
public abstract void AddForceSync(Vector3 Force, Vector3 forceOffset, ForceType type);
public abstract void AddForceSync(Vector3 Force, Vector3 forceOffset, ForceType type);
public void SendCreateEntitySetData(EntityId senderId, EntityId recieverId, int requestId, EntityType entityType, XYZ location, ForceType ForceType, double psi, double theta, double phi)
{
NetSimAgent.Instance.SendCreateEntitySetData(ExerciseConnectionPtr, senderId, recieverId, requestId, entityType, location, ForceType, psi, theta, phi);
}
/// <summary>
/// 添加力
/// </summary>
/// <param name="force">力</param>
/// <param name="forcetype">力的类型</param>
/// <param name="bWakeUp">是否唤醒Actor</param>
public void AddForce(Vector3 force, ForceType forcetype, bool bWakeUp)
{
ICall_PhysicsBodyComponent_AddForce(this, ref force, forcetype, bWakeUp);
}
public override void AddForceSync(Vector3 Force, Vector3 forceOffset, ForceType type)
{
// TODO Maybe
}
internal void AddAngularForce(OpenMetaverse.Vector3 force, ForceType ftype)
{
if (PhysicsActor != null)
{
PhysicsActor.AddAngularForce(force, ftype);
}
}
/// <summary>
/// Applies a force to this <see cref="Entity"/>.
/// </summary>
/// <param name="direction">The direction to apply the force relative to this <see cref="Entity"/>s rotation</param>
/// <param name="rotation">The rotation force to apply</param>
/// <param name="forceType">Type of the force to apply.</param>
public void ApplyForceRelative(Vector3 direction, Vector3 rotation = default(Vector3), ForceType forceType = ForceType.MaxForceRot2)
{
Function.Call(Hash.APPLY_FORCE_TO_ENTITY, Handle, forceType, direction.X, direction.Y, direction.Z, rotation.X, rotation.Y, rotation.Z, false, true, true, true, false, true);
}
private void CloseScene(string sn, bool immediate, ForceType force = ForceType.NO_FORCE, AnimType animType = AnimType.HIDE, NoParamCallback callback = null)
{
// Event
SSController ct = m_Dict[sn].GetComponentInChildren<SSController>();
if (ct != null)
{
ct.OnHide();
}
// Play Animation
if (!immediate)
{
StartCoroutine( IEPlayAnimation (sn, animType, () =>
{
// Deactive or Destroy
DeactiveOrDestroy(sn, force);
if (callback != null)
callback();
}));
}
else
{
// Deactive or Destroy
DeactiveOrDestroy(sn, force);
if (callback != null)
callback();
}
}
internal void AddAngularForce(OpenMetaverse.Vector3 force, ForceType ftype)
{
var pa = PhysicsActor;
if (pa != null)
{
pa.AddAngularForce(force, ftype);
}
}
private List <FramePointResult> GetFrameForceList(string ComboName, ForceType ForceType)
{
EtabsModel.Results.Setup.DeselectAllCasesAndCombosForOutput();
var ret1 = EtabsModel.Results.Setup.SetComboSelectedForOutput(ComboName);
int NumberResults = 0;
string[] _Obj = null;
double[] _ObjSta = null;
string[] _Elm = null;
double[] _ElmSta = null;
string[] _LoadCase = null;
string[] _StepType = null;
double[] _StepNum = null;
double[] _P = null;
double[] _V2 = null;
double[] _V3 = null;
double[] _T = null;
double[] _M2 = null;
double[] _M3 = null;
eItemTypeElm elementType = eItemTypeElm.ObjectElm;
var ret2 = EtabsModel.Results.FrameForce(this.Name, elementType,
ref NumberResults,
ref _Obj,
ref _ObjSta,
ref _Elm,
ref _ElmSta,
ref _LoadCase,
ref _StepType,
ref _StepNum,
ref _P,
ref _V2,
ref _V3,
ref _T,
ref _M2,
ref _M3);
List <FramePointResult> outputList = new List <FramePointResult>();
if (NumberResults > 0)
{
List <double> Values = new List <double>();
List <double> Stations = ArrayToListConverter.Convert <double>(_ObjSta);
switch (ForceType)
{
case ForceType.Fx:
Values = ArrayToListConverter.Convert <double>(_P);
break;
case ForceType.Fy:
Values = ArrayToListConverter.Convert <double>(_V2);
break;
case ForceType.Fz:
Values = ArrayToListConverter.Convert <double>(_V3);
break;
case ForceType.Mx:
Values = ArrayToListConverter.Convert <double>(_T);
break;
case ForceType.My:
Values = ArrayToListConverter.Convert <double>(_M2);
break;
case ForceType.Mz:
Values = ArrayToListConverter.Convert <double>(_M3);
break;
}
for (int i = 0; i < Values.Count; i++)
{
outputList.Add(new FramePointResult()
{
ResultValue = Values[i], Station = Stations[i]
});
}
}
return(outputList);
}
/// <summary>
/// 在本地位置添加本地力
/// </summary>
/// <param name="force">力</param>
/// <param name="pos">力的施加位置</param>
/// <param name="forcetype">力的类型</param>
/// <param name="bWakeUp">是否唤醒Actor</param>
public void AddLocalForceAtLocalPos(Vector3 force, Vector3 pos, ForceType forcetype, bool bWakeUp)
{
ICall_PhysicsBodyComponent_AddLocalForceAtLocalPos(this, ref force, ref pos, forcetype, bWakeUp);
}
public override void AddForceSync(OpenMetaverse.Vector3 Force, OpenMetaverse.Vector3 forceOffset, ForceType type)
{
//these property setter force types need to be set and assigned regardless
//of if the object is currently a free dynamic
switch (type)
{
case ForceType.AngularVelocityTarget:
lock (_properties)
{
_properties.AngularVelocityTarget = Force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantGlobalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = false;
_properties.Force = Force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantLocalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = true;
_properties.Force = Force;
}
RequestPhysicsNeedsPersistence();
break;
}
//in all cases, wake up
//this.WakeUp();
}
public override void AddAngularForce(Vector3 force, ForceType ftype)
{
}
protected override void ApplyForce( ForceType type, ref Vec3 vector, ref Vec3 pos )
{
if( nativeBody != IntPtr.Zero && !Static )
{
switch( type )
{
case ForceType.Local:
PhysXNativeBody.AddLocalForce( nativeBody, ref vector );
break;
case ForceType.Global:
PhysXNativeBody.AddForce( nativeBody, ref vector );
break;
case ForceType.LocalTorque:
PhysXNativeBody.AddLocalTorque( nativeBody, ref vector );
break;
case ForceType.GlobalTorque:
PhysXNativeBody.AddTorque( nativeBody, ref vector );
break;
case ForceType.LocalAtLocalPos:
PhysXNativeBody.AddLocalForceAtLocalPos( nativeBody, ref vector, ref pos );
break;
case ForceType.LocalAtGlobalPos:
PhysXNativeBody.AddLocalForceAtPos( nativeBody, ref vector, ref pos );
break;
case ForceType.GlobalAtLocalPos:
PhysXNativeBody.AddForceAtLocalPos( nativeBody, ref vector, ref pos );
break;
case ForceType.GlobalAtGlobalPos:
PhysXNativeBody.AddForceAtPos( nativeBody, ref vector, ref pos );
break;
}
}
}
public abstract void AddAngularForce(OpenMetaverse.Vector3 force, ForceType ftype);
public override void AddForceSync(OpenMetaverse.Vector3 force, OpenMetaverse.Vector3 forceOffset, ForceType type)
{
PhysX.Math.Vector3 pforce = PhysUtil.OmvVectorToPhysx(force);
PhysX.Math.Vector3 poffset = PhysUtil.OmvVectorToPhysx(forceOffset);
//these property setter force types need to be set and assigned regardless
//of if the object is currently a free dynamic
switch (type)
{
case ForceType.AngularVelocityTarget:
lock (_properties)
{
_properties.AngularVelocityTarget = force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantGlobalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = false;
_properties.Force = force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantLocalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = true;
_properties.Force = force;
}
RequestPhysicsNeedsPersistence();
break;
}
if (IsFreeDynamic)
{
switch (type)
{
case ForceType.LocalAngularImpulse:
_dynActor.AddTorque(PhysUtil.OmvVectorToPhysx(force * _rotation), PhysX.ForceMode.Impulse, true);
break;
case ForceType.GlobalAngularImpulse: // this really means GlobalAngularImpulse
_dynActor.AddTorque(pforce, PhysX.ForceMode.Impulse, true);
break;
case ForceType.LocalLinearImpulse:
_dynActor.AddLocalForceAtLocalPosition(PhysUtil.OmvVectorToPhysx(force), PhysUtil.OmvVectorToPhysx(_centerOfMassLocalPose.Position), PhysX.ForceMode.Impulse, true);
break;
case ForceType.GlobalLinearImpulse:
if (poffset == PhysX.Math.Vector3.Zero)
_dynActor.AddForce(pforce, PhysX.ForceMode.Impulse, true);
else
_dynActor.AddForceAtLocalPosition(pforce, poffset, PhysX.ForceMode.Impulse, true);
break;
case ForceType.ReplaceGlobalAngularVelocity:
this.ReplaceAngularVelocity(force, false);
break;
case ForceType.ReplaceLocalAngularVelocity:
this.ReplaceAngularVelocity(force, true);
break;
case ForceType.ReplaceLocalLinearVelocity:
this.ReplaceLinearVelocity(force, true);
break;
case ForceType.ReplaceGlobalLinearVelocity:
this.ReplaceLinearVelocity(force, false);
break;
}
}
//in all cases, wake up
this.WakeUp();
}
/// <summary>
/// Applies a force to this <see cref="Entity"/>.
/// </summary>
/// <param name="direction">The direction to apply the force relative to this <see cref="Entity"/>s rotation</param>
/// <param name="rotation">The rotation force to apply</param>
/// <param name="forceType">Type of the force to apply.</param>
public void ApplyForceRelative(Vector3 direction, Vector3 rotation = default(Vector3), ForceType forceType = ForceType.MaxForceRot2)
{
API.ApplyForceToEntity(Handle, (int)forceType, direction.X, direction.Y, direction.Z, rotation.X, rotation.Y, rotation.Z, 0, true, true, true, false, true);
}
public override void AddForceSync(OpenMetaverse.Vector3 Force, OpenMetaverse.Vector3 forceOffset, ForceType type)
{
//these property setter force types need to be set and assigned regardless
//of if the object is currently a free dynamic
switch (type)
{
case ForceType.AngularVelocityTarget:
lock (_properties)
{
_properties.AngularVelocityTarget = Force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantGlobalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = false;
_properties.Force = Force;
}
RequestPhysicsNeedsPersistence();
break;
case ForceType.ConstantLocalLinearForce:
lock (_properties)
{
_properties.ForceIsLocal = true;
_properties.Force = Force;
}
RequestPhysicsNeedsPersistence();
break;
}
//in all cases, wake up
//this.WakeUp();
}
/// <summary>
/// 在世界位置添加本地力
/// </summary>
/// <param name="force">力</param>
/// <param name="pos">力的施加位置</param>
/// <param name="forcetype">力的类型</param>
/// <param name="bWakeUp">是否唤醒Actor</param>
public void AddLocalForceAtPos(Vector3 force, Vector3 pos, ForceType forcetype, bool bWakeUp)
{
ICall_PhysicsBodyComponent_AddLocalForceAtPos(this, ref force, ref pos, forcetype, bWakeUp);
}
//public override Mat3 GetInertiaTensor()
//{
// if( Static )
// return Mat3.Identity;
// if( bodyID == dBodyID.Zero )
// return Mat3.Zero;
// Ode.dMass mass = new Ode.dMass();
// Ode.dBodyGetMass( bodyID, ref mass );
// return new Mat3(
// mass.I.M00, mass.I.M01, mass.I.M02,
// mass.I.M10, mass.I.M11, mass.I.M12,
// mass.I.M20, mass.I.M21, mass.I.M22 );
//}
protected override void ApplyForce( ForceType type, ref Vec3 vector, ref Vec3 pos )
{
if( bodyID == dBodyID.Zero )
return;
Ode.dBodyEnable( bodyID );
switch( type )
{
case ForceType.Local:
Ode.dBodyAddRelForce( bodyID, vector.X, vector.Y, vector.Z );
break;
case ForceType.Global:
Ode.dBodyAddForce( bodyID, vector.X, vector.Y, vector.Z );
break;
case ForceType.LocalTorque:
Ode.dBodyAddRelTorque( bodyID, vector.X, vector.Y, vector.Z );
break;
case ForceType.GlobalTorque:
Ode.dBodyAddTorque( bodyID, vector.X, vector.Y, vector.Z );
break;
case ForceType.LocalAtLocalPos:
Ode.dBodyAddRelForceAtRelPos( bodyID, vector.X, vector.Y, vector.Z, pos.X, pos.Y, pos.Z );
break;
case ForceType.LocalAtGlobalPos:
Ode.dBodyAddRelForceAtPos( bodyID, vector.X, vector.Y, vector.Z, pos.X, pos.Y, pos.Z );
break;
case ForceType.GlobalAtLocalPos:
Ode.dBodyAddForceAtRelPos( bodyID, vector.X, vector.Y, vector.Z, pos.X, pos.Y, pos.Z );
break;
case ForceType.GlobalAtGlobalPos:
Ode.dBodyAddForceAtPos( bodyID, vector.X, vector.Y, vector.Z, pos.X, pos.Y, pos.Z );
break;
}
//// Invalidate the "freely-spinning" parameter.
//freelySpinning = false;
}
