mirror of
https://github.com/opensim/opensim.git
synced 2026-06-02 08:35:35 +08:00
2274 lines
72 KiB
C#
2274 lines
72 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
// Revision by Ubit 2011/12
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.PhysicsModules.SharedBase;
|
|
using log4net;
|
|
|
|
namespace OpenSim.Region.PhysicsModule.ubOde
|
|
{
|
|
/// <summary>
|
|
/// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
|
|
/// </summary>
|
|
|
|
public enum dParam : int
|
|
{
|
|
LowStop = 0,
|
|
HiStop = 1,
|
|
Vel = 2,
|
|
FMax = 3,
|
|
FudgeFactor = 4,
|
|
Bounce = 5,
|
|
CFM = 6,
|
|
StopERP = 7,
|
|
StopCFM = 8,
|
|
LoStop2 = 256,
|
|
HiStop2 = 257,
|
|
Vel2 = 258,
|
|
FMax2 = 259,
|
|
StopERP2 = 7 + 256,
|
|
StopCFM2 = 8 + 256,
|
|
LoStop3 = 512,
|
|
HiStop3 = 513,
|
|
Vel3 = 514,
|
|
FMax3 = 515,
|
|
StopERP3 = 7 + 512,
|
|
StopCFM3 = 8 + 512
|
|
}
|
|
|
|
public class OdeCharacter : PhysicsActor
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
internal AABB2D _AABB2D;
|
|
internal Vector3 _position;
|
|
public int Colliderfilter = 0;
|
|
|
|
public float CapsuleSizeZ;
|
|
public float CapsuleRadius;
|
|
internal Vector2 Orientation2D;
|
|
internal float AvaSizeXsq = 0.3f;
|
|
internal float AvaSizeYsq = 0.2f;
|
|
internal float feetOff = 0;
|
|
internal float boneOff = 0;
|
|
|
|
public IntPtr Body = IntPtr.Zero;
|
|
|
|
public int m_bodydisablecontrol = 0;
|
|
private float m_scenegravityForceZ;
|
|
int m_colliderObjectfilter = 0;
|
|
int m_colliderGroundfilter = 0;
|
|
|
|
private UBOdeNative.Quaternion m_NativeOrientation2D;
|
|
private Vector3 _zeroPosition;
|
|
internal Quaternion m_orientation;
|
|
private Vector3 _velocity;
|
|
private Vector3 m_rotationalVelocity;
|
|
private Vector3 _acceleration;
|
|
private Vector3 m_lastFallVel;
|
|
|
|
private Vector3 m_size;
|
|
|
|
private float m_mass = 80f;
|
|
private float m_massInvTimeScaled = 1600f;
|
|
public readonly float m_density = 60f;
|
|
private bool m_pidControllerActive = true;
|
|
|
|
internal Vector3 CollideNormal;
|
|
|
|
public int _charsListIndex;
|
|
|
|
|
|
const float basePID_D = 0.55f; // scaled for unit mass unit time (2200 /(50*80))
|
|
const float basePID_P = 0.225f; // scaled for unit mass unit time (900 /(50*80))
|
|
|
|
public float PID_D;
|
|
public float PID_P;
|
|
|
|
private readonly ODEScene m_parent_scene;
|
|
|
|
private readonly float m_sceneTimeStep;
|
|
private readonly float m_sceneInverseTimeStep;
|
|
|
|
public readonly float m_walkMultiplier = 1.0f / 1.3f;
|
|
public readonly float m_runMultiplier = 1.0f / 0.8f;
|
|
private bool m_flying = false;
|
|
private bool m_iscolliding = false;
|
|
private bool m_iscollidingGround = false;
|
|
private bool m_iscollidingObj = false;
|
|
|
|
private bool _zeroFlag = false;
|
|
private bool m_haveLastFallVel = false;
|
|
|
|
public bool m_returnCollisions = false;
|
|
// taints and their non-tainted counterparts
|
|
public bool m_isPhysical = false; // the current physical status
|
|
public float MinimumGroundFlightOffset = 3f;
|
|
|
|
private bool m_freemove = false;
|
|
|
|
// private string m_name = String.Empty;
|
|
// other filter control
|
|
|
|
// Default we're a Character
|
|
private const CollisionCategories m_collisionCategories = (CollisionCategories.Character);
|
|
|
|
// Default, Collide with Other Geometries, spaces, bodies and characters.
|
|
private const CollisionCategories m_collisionFlags = (CollisionCategories.Character
|
|
| CollisionCategories.Geom
|
|
| CollisionCategories.VolumeDtc
|
|
);
|
|
// we do land collisions not ode | CollisionCategories.Land);
|
|
//private IntPtr capsule = IntPtr.Zero;
|
|
public IntPtr collider = IntPtr.Zero;
|
|
|
|
public IntPtr Amotor = IntPtr.Zero;
|
|
|
|
internal UBOdeNative.Mass ShellMass;
|
|
|
|
public int m_eventsubscription = 0;
|
|
private int m_cureventsubscription = 0;
|
|
private readonly CollisionEventUpdate CollisionEventsThisFrame = new();
|
|
private bool SentEmptyCollisionsEvent;
|
|
|
|
public bool bad = false;
|
|
|
|
private readonly float m_frictionmu;
|
|
|
|
// HoverHeight control
|
|
private float m_PIDHoverHeight;
|
|
private float m_PIDHoverTau;
|
|
private bool m_useHoverPID;
|
|
private PIDHoverType m_PIDHoverType;
|
|
private float m_targetHoverHeight;
|
|
|
|
public OdeCharacter(uint localID, String avName, ODEScene parent_scene, Vector3 pos, Vector3 pSize, float pfeetOffset, float density, float walk_divisor, float rundivisor)
|
|
{
|
|
m_baseLocalID = localID;
|
|
m_parent_scene = parent_scene;
|
|
|
|
m_sceneTimeStep = parent_scene.ODE_STEPSIZE;
|
|
m_sceneInverseTimeStep = 1.0f / m_sceneTimeStep;
|
|
|
|
if (pos.IsFinite())
|
|
{
|
|
if (pos.Z > Constants.MaxSimulationHeight)
|
|
{
|
|
pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
|
|
}
|
|
if (pos.Z < Constants.MinSimulationHeight) // shouldn't this be 0 ?
|
|
{
|
|
pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
|
|
}
|
|
_position = pos;
|
|
}
|
|
else
|
|
{
|
|
_position = new Vector3(((float)m_parent_scene.WorldExtents.X * 0.5f), ((float)m_parent_scene.WorldExtents.Y * 0.5f), parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
|
|
m_log.Warn("[PHYSICS]: Got NaN Position on Character Create");
|
|
}
|
|
|
|
m_size.X = pSize.X > 0.01f ? 0.5f * pSize.X : 0.01f;
|
|
m_size.Y = pSize.Y > 0.01f ? 0.5f * pSize.Y : 0.01f;
|
|
m_size.Z = pSize.Z > 0.01f ? 0.5f * pSize.Z : 0.01f;
|
|
|
|
CapsuleRadius = MathF.Max(m_size.X, m_size.Y);
|
|
CapsuleSizeZ = m_size.Z;
|
|
|
|
AvaSizeXsq = m_size.X;
|
|
AvaSizeXsq *= AvaSizeXsq;
|
|
AvaSizeYsq = m_size.Y;
|
|
AvaSizeYsq *= AvaSizeYsq;
|
|
|
|
m_orientation = Quaternion.Identity;
|
|
Orientation2D = new(0f, 1f);
|
|
m_NativeOrientation2D.X = 0f;
|
|
m_NativeOrientation2D.Y = 0f;
|
|
m_NativeOrientation2D.Z = 0f;
|
|
m_NativeOrientation2D.W = 1f;
|
|
|
|
m_density = density;
|
|
|
|
// force lower density for testing
|
|
m_density = 3.0f;
|
|
|
|
m_frictionmu = m_parent_scene.AvatarFriction;
|
|
|
|
m_walkMultiplier = 1.0f / walk_divisor;
|
|
m_runMultiplier = 1.0f / rundivisor;
|
|
|
|
m_mass = 8f * m_density * m_size.X * m_size.Y * m_size.Z;
|
|
m_massInvTimeScaled = m_mass * m_sceneInverseTimeStep;
|
|
// sure we have a default
|
|
|
|
PID_D = basePID_D * m_massInvTimeScaled;
|
|
PID_P = basePID_P * m_massInvTimeScaled;
|
|
|
|
m_scenegravityForceZ = parent_scene.gravityz * m_mass;
|
|
|
|
m_isPhysical = false; // current status: no ODE information exists
|
|
|
|
Name = avName;
|
|
|
|
UpdateAABB2D();
|
|
|
|
AddChange(changes.Add, null);
|
|
}
|
|
|
|
public override int PhysicsActorType
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return (int)ActorTypes.Agent;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void getContactData(ref ContactData cdata)
|
|
{
|
|
cdata.mu = m_frictionmu;
|
|
cdata.bounce = 0;
|
|
cdata.softcolide = false;
|
|
}
|
|
|
|
public override bool Building
|
|
{
|
|
get; set;
|
|
}
|
|
|
|
/// <summary>
|
|
/// If this is set, the avatar will move faster
|
|
/// </summary>
|
|
private bool m_alwaysRun = false;
|
|
public override bool SetAlwaysRun
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_alwaysRun;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
m_alwaysRun = value;
|
|
}
|
|
}
|
|
|
|
public override PhysicsActor ParentActor
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return (PhysicsActor)this;
|
|
}
|
|
}
|
|
|
|
public override bool Grabbed
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override bool Selected
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
private float m_buoyancy = 0f;
|
|
public override float Buoyancy
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_buoyancy;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
m_buoyancy = value;
|
|
}
|
|
}
|
|
|
|
public override bool IsPhysical
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_isPhysical;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override bool ThrottleUpdates
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override bool Flying
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_flying;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
m_flying = value;
|
|
//m_log.DebugFormat("[PHYSICS]: Set OdeCharacter Flying to {0}", flying);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if the avatar is colliding in general.
|
|
/// This includes the ground and objects and avatar.
|
|
/// </summary>
|
|
public override bool IsColliding
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return (m_iscolliding || m_iscollidingGround);
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
Colliderfilter += 3;
|
|
if (Colliderfilter > 9)
|
|
Colliderfilter = 9;
|
|
}
|
|
else
|
|
{
|
|
Colliderfilter--;
|
|
if (Colliderfilter < 0)
|
|
Colliderfilter = 0;
|
|
}
|
|
|
|
if (Colliderfilter < 6)
|
|
m_iscolliding = false;
|
|
else
|
|
{
|
|
m_pidControllerActive = true;
|
|
m_iscolliding = true;
|
|
m_freemove = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if an avatar is colliding with the ground
|
|
/// </summary>
|
|
public override bool CollidingGround
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_iscollidingGround;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
/* we now control this
|
|
if (value)
|
|
{
|
|
m_colliderGroundfilter += 2;
|
|
if (m_colliderGroundfilter > 2)
|
|
m_colliderGroundfilter = 2;
|
|
}
|
|
else
|
|
{
|
|
m_colliderGroundfilter--;
|
|
if (m_colliderGroundfilter < 0)
|
|
m_colliderGroundfilter = 0;
|
|
}
|
|
|
|
if (m_colliderGroundfilter == 0)
|
|
m_iscollidingGround = false;
|
|
else
|
|
m_iscollidingGround = true;
|
|
*/
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if the avatar is colliding with an object
|
|
/// </summary>
|
|
public override bool CollidingObj
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_iscollidingObj;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
m_colliderObjectfilter += 2;
|
|
if (m_colliderObjectfilter > 2)
|
|
m_colliderObjectfilter = 2;
|
|
}
|
|
else
|
|
{
|
|
m_colliderObjectfilter--;
|
|
if (m_colliderObjectfilter < 0)
|
|
m_colliderObjectfilter = 0;
|
|
}
|
|
|
|
if (m_colliderObjectfilter == 0)
|
|
m_iscollidingObj = false;
|
|
else
|
|
m_iscollidingObj = true;
|
|
|
|
// m_iscollidingObj = value;
|
|
|
|
if (m_iscollidingObj)
|
|
m_pidControllerActive = false;
|
|
else
|
|
m_pidControllerActive = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// turn the PID controller on or off.
|
|
/// The PID Controller will turn on all by itself in many situations
|
|
/// </summary>
|
|
/// <param name="status"></param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void SetPidStatus(bool status)
|
|
{
|
|
m_pidControllerActive = status;
|
|
}
|
|
|
|
public override bool Stopped
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return _zeroFlag;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This 'puts' an avatar somewhere in the physics space.
|
|
/// Not really a good choice unless you 'know' it's a good
|
|
/// spot otherwise you're likely to orbit the avatar.
|
|
/// </summary>
|
|
public override Vector3 Position
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return _position;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value.IsFinite())
|
|
{
|
|
if (value.Z < -100f || value.Z > 9999999f)
|
|
value.Z = m_parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
|
|
|
|
AddChange(changes.Position, value);
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN Position from Scene on a Character");
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Vector3 RotationalVelocity
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_rotationalVelocity;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
m_rotationalVelocity = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This property sets the height of the avatar only. We use the height to make sure the avatar stands up straight
|
|
/// and use it to offset landings properly
|
|
/// </summary>
|
|
public override Vector3 Size
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_size * 2f;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value.IsFinite())
|
|
{
|
|
if (value.X < 0.01f)
|
|
value.X = 0.01f;
|
|
if (value.Y < 0.01f)
|
|
value.Y = 0.01f;
|
|
if (value.Z < 0.01f)
|
|
value.Z = 0.01f;
|
|
|
|
AddChange(changes.Size, value);
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
|
|
}
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void setAvatarSize(Vector3 size, float feetOffset)
|
|
{
|
|
if (size.IsFinite())
|
|
{
|
|
if (size.X < 0.01f)
|
|
size.X = 0.01f;
|
|
if (size.Y < 0.01f)
|
|
size.Y = 0.01f;
|
|
if (size.Z < 0.01f)
|
|
size.Z = 0.01f;
|
|
|
|
strAvatarSize st = new()
|
|
{
|
|
size = size,
|
|
};
|
|
AddChange(changes.AvatarSize, st);
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN AvatarSize from Scene on a Character");
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Uses the capped cyllinder volume formula to calculate the avatar's mass.
|
|
/// This may be used in calculations in the scene/scenepresence
|
|
/// </summary>
|
|
public override float Mass
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_mass;
|
|
}
|
|
}
|
|
public override void link(PhysicsActor obj)
|
|
{
|
|
|
|
}
|
|
|
|
public override void delink()
|
|
{
|
|
|
|
}
|
|
|
|
public override void LockAngularMotion(byte axislocks)
|
|
{
|
|
|
|
}
|
|
|
|
public override Vector3 Force
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_targetVelocity;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override int VehicleType
|
|
{
|
|
get
|
|
{
|
|
return 0;
|
|
}
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override void VehicleFloatParam(int param, float value)
|
|
{
|
|
|
|
}
|
|
|
|
public override void VehicleVectorParam(int param, Vector3 value)
|
|
{
|
|
|
|
}
|
|
|
|
public override void VehicleRotationParam(int param, Quaternion rotation)
|
|
{
|
|
|
|
}
|
|
|
|
public override void VehicleFlags(int param, bool remove)
|
|
{
|
|
|
|
}
|
|
|
|
public override void SetVolumeDetect(int param)
|
|
{
|
|
|
|
}
|
|
|
|
public override Vector3 CenterOfMass
|
|
{
|
|
get
|
|
{
|
|
return _position;
|
|
}
|
|
}
|
|
|
|
public override Vector3 GeometricCenter
|
|
{
|
|
get
|
|
{
|
|
return _position;
|
|
}
|
|
}
|
|
|
|
public override PrimitiveBaseShape Shape
|
|
{
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override Vector3 rootVelocity
|
|
{
|
|
get
|
|
{
|
|
return _velocity;
|
|
}
|
|
}
|
|
|
|
public override Vector3 Velocity
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return _velocity;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value.IsFinite())
|
|
{
|
|
AddChange(changes.Velocity, value);
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Vector3 TargetVelocity
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_targetVelocity;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
if (value.IsFinite())
|
|
{
|
|
AddChange(changes.TargetVelocity, value);
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Vector3 Torque
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return Vector3.Zero;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override float CollisionScore
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return 0f;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override bool Kinematic
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override Quaternion Orientation
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_orientation;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
//fakeori = value;
|
|
//givefakeori++;
|
|
value.Normalize();
|
|
AddChange(changes.Orientation, value);
|
|
}
|
|
}
|
|
|
|
public override Vector3 Acceleration
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return _acceleration;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void SetAcceleration(Vector3 accel)
|
|
{
|
|
m_pidControllerActive = true;
|
|
_acceleration = accel;
|
|
if (Body != IntPtr.Zero)
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the force supplied to the Target Velocity
|
|
/// The PID controller takes this target velocity and tries to make it a reality
|
|
/// </summary>
|
|
/// <param name="force"></param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void AddForce(Vector3 force, bool pushforce)
|
|
{
|
|
if (force.IsFinite())
|
|
{
|
|
if (pushforce)
|
|
{
|
|
AddChange(changes.Force, force * m_density * m_sceneInverseTimeStep / 28f);
|
|
}
|
|
else
|
|
{
|
|
AddChange(changes.TargetVelocity, force);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN force applied to a Character");
|
|
}
|
|
//m_lastUpdateSent = false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void AvatarJump(float impulseZ)
|
|
{
|
|
// convert back to force and remove mass effect
|
|
AddChange(changes.Force, new Vector3(0, 0, impulseZ * m_massInvTimeScaled));
|
|
}
|
|
|
|
public override void AddAngularForce(Vector3 force, bool pushforce)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void SetMomentum(Vector3 momentum)
|
|
{
|
|
if (momentum.IsFinite())
|
|
AddChange(changes.Momentum, momentum);
|
|
}
|
|
|
|
|
|
private void AvatarGeomAndBodyCreate()
|
|
{
|
|
float sx = m_size.X;
|
|
float sy = m_size.Y;
|
|
float sz = m_size.Z;
|
|
|
|
float bot = -sz;
|
|
boneOff = bot + 0.3f;
|
|
|
|
float feetsz = sz * 0.45f;
|
|
if (feetsz > 0.6f)
|
|
feetsz = 0.6f;
|
|
feetOff = bot + feetsz;
|
|
|
|
AvaSizeXsq = sx;
|
|
AvaSizeXsq *= AvaSizeXsq;
|
|
AvaSizeYsq = sy;
|
|
AvaSizeYsq *= AvaSizeYsq;
|
|
|
|
CapsuleRadius = MathF.Max(sx, sy);
|
|
float l = sz - CapsuleRadius;
|
|
CapsuleSizeZ = sz;
|
|
|
|
collider = UBOdeNative.CreateCapsule(m_parent_scene.TopSpace, CapsuleRadius, 2.0f * l);
|
|
UBOdeNative.GeomSetCategoryBits(collider, (uint)m_collisionCategories);
|
|
UBOdeNative.GeomSetCollideBits(collider, (uint)m_collisionFlags);
|
|
|
|
// update mass
|
|
m_mass = 8f * m_density * sx * sy * sz;
|
|
UBOdeNative.MassSetBoxTotal(out ShellMass, m_mass, 2f * sx, 2f * sy, 2f * sz);
|
|
m_massInvTimeScaled = m_mass * m_sceneInverseTimeStep;
|
|
PID_D = basePID_D * m_massInvTimeScaled;
|
|
PID_P = basePID_P * m_massInvTimeScaled;
|
|
m_scenegravityForceZ = m_parent_scene.gravityz * m_mass;
|
|
|
|
Body = UBOdeNative.BodyCreate(m_parent_scene.world);
|
|
|
|
_zeroFlag = false;
|
|
m_pidControllerActive = true;
|
|
m_freemove = false;
|
|
|
|
_velocity = Vector3.Zero;
|
|
|
|
// SafeNativeMethods.BodySetAutoDisableFlag(Body,false);
|
|
UBOdeNative.BodySetAutoDisableFlag(Body, true);
|
|
m_bodydisablecontrol = 0;
|
|
|
|
UBOdeNative.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
|
|
|
|
UBOdeNative.BodySetMass(Body, ref ShellMass);
|
|
//SafeNativeMethods.GeomSetBody(capsule, Body);
|
|
UBOdeNative.GeomSetBody(collider, Body);
|
|
|
|
// The purpose of the AMotor here is to keep the avatar's physical
|
|
// surrogate from rotating while moving
|
|
Amotor = UBOdeNative.JointCreateAMotor(m_parent_scene.world, IntPtr.Zero);
|
|
UBOdeNative.JointAttach(Amotor, Body, IntPtr.Zero);
|
|
|
|
UBOdeNative.JointSetAMotorMode(Amotor, 0);
|
|
UBOdeNative.JointSetAMotorNumAxes(Amotor, 3);
|
|
UBOdeNative.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
|
|
UBOdeNative.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
|
|
UBOdeNative.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
|
|
|
|
UBOdeNative.JointSetAMotorAngle(Amotor, 0, 0);
|
|
UBOdeNative.JointSetAMotorAngle(Amotor, 1, 0);
|
|
UBOdeNative.JointSetAMotorAngle(Amotor, 2, 0);
|
|
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopCFM, 0f); // make it HARD
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopCFM2, 0f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopCFM3, 0f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopERP, 0.8f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopERP2, 0.8f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.StopERP3, 0.8f);
|
|
|
|
// These lowstops and high stops are effectively (no wiggle room)
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -1e-5f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 1e-5f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -1e-5f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 1e-5f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -1e-5f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 1e-5f);
|
|
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)UBOdeNative.JointParam.Vel, 0);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)UBOdeNative.JointParam.Vel2, 0);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)UBOdeNative.JointParam.Vel3, 0);
|
|
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.FMax, 5e8f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.FMax2, 5e8f);
|
|
UBOdeNative.JointSetAMotorParam(Amotor, (int)dParam.FMax3, 5e8f);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Destroys the avatar body and geom
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void AvatarGeomAndBodyDestroy()
|
|
{
|
|
// Kill the Amotor
|
|
if (Amotor != IntPtr.Zero)
|
|
{
|
|
UBOdeNative.JointDestroy(Amotor);
|
|
Amotor = IntPtr.Zero;
|
|
}
|
|
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
//kill the body
|
|
UBOdeNative.BodyDestroy(Body);
|
|
Body = IntPtr.Zero;
|
|
}
|
|
|
|
//kill the Geoms
|
|
/*
|
|
if (capsule != IntPtr.Zero)
|
|
{
|
|
m_parent_scene.actor_name_map.Remove(capsule);
|
|
//m_parent_scene.waitForSpaceUnlock(collider);
|
|
SafeNativeMethods.GeomDestroy(capsule);
|
|
capsule = IntPtr.Zero;
|
|
}
|
|
|
|
if (collider != IntPtr.Zero)
|
|
{
|
|
SafeNativeMethods.SpaceDestroy(collider);
|
|
collider = IntPtr.Zero;
|
|
}
|
|
*/
|
|
if (collider != IntPtr.Zero)
|
|
{
|
|
m_parent_scene.actor_name_map.Remove(collider);
|
|
//m_parent_scene.waitForSpaceUnlock(m_parent_scene.CharsSpace);
|
|
UBOdeNative.GeomDestroy(collider);
|
|
collider = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
//in place 2D rotation around Z assuming rot is normalised and is a rotation around Z
|
|
public static void RotateXYonZ(ref float x, ref float y, ref Quaternion rot)
|
|
{
|
|
float sin = 2.0f * rot.Z * rot.W;
|
|
float cos = rot.W * rot.W - rot.Z * rot.Z;
|
|
float tx = x;
|
|
|
|
x = tx * cos - y * sin;
|
|
y = tx * sin + y * cos;
|
|
}
|
|
public static void RotateXYonZ(ref float x, ref float y, float sin, float cos)
|
|
{
|
|
float tx = x;
|
|
x = tx * cos - y * sin;
|
|
y = tx * sin + y * cos;
|
|
}
|
|
public static void invRotateXYonZ(ref float x, ref float y, float sin, float cos)
|
|
{
|
|
float tx = x;
|
|
x = tx * cos + y * sin;
|
|
y = -tx * sin + y * cos;
|
|
}
|
|
|
|
public static void invRotateXYonZ(ref float x, ref float y, in Quaternion rot)
|
|
{
|
|
float sin = -2.0f * rot.Z * rot.W;
|
|
float cos = rot.W * rot.W - rot.Z * rot.Z;
|
|
float tx = x;
|
|
|
|
x = tx * cos - y * sin;
|
|
y = tx * sin + y * cos;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal bool Collide(IntPtr other, bool reverse, ref UBOdeNative.ContactGeom contact,
|
|
ref UBOdeNative.ContactGeom altContact, ref bool useAltcontact, ref bool feetcollision)
|
|
{
|
|
feetcollision = false;
|
|
useAltcontact = false;
|
|
|
|
Vector3 offset;
|
|
|
|
float h = contact.pos.Z - _position.Z;
|
|
offset.Z = h - feetOff;
|
|
|
|
offset.X = contact.pos.X - _position.X;
|
|
offset.Y = contact.pos.Y - _position.Y;
|
|
|
|
UBOdeNative.GeomClassID gtype = UBOdeNative.GeomGetClass(other);
|
|
|
|
if (gtype == UBOdeNative.GeomClassID.SphereClass && UBOdeNative.GeomGetBody(other) != IntPtr.Zero)
|
|
{
|
|
if (UBOdeNative.GeomSphereGetRadius(other) < 0.5)
|
|
return true;
|
|
}
|
|
|
|
if (offset.Z > 0 || contact.normal.Z > 0.35f)
|
|
{
|
|
if (offset.Z <= 0)
|
|
{
|
|
feetcollision = true;
|
|
if (h < boneOff)
|
|
{
|
|
CollideNormal = Unsafe.As<UBOdeNative.Vector3, Vector3>(ref contact.normal);
|
|
IsColliding = true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (m_flying)
|
|
return true;
|
|
|
|
feetcollision = true;
|
|
if (h < boneOff)
|
|
{
|
|
CollideNormal = Unsafe.As<UBOdeNative.Vector3, Vector3>(ref contact.normal);
|
|
IsColliding = true;
|
|
}
|
|
|
|
useAltcontact = true;
|
|
|
|
offset.Z -= 0.2f;
|
|
|
|
offset.Normalize();
|
|
|
|
float tdp = contact.depth;
|
|
float t = offset.X;
|
|
t = MathF.Abs(t);
|
|
if (t > 1e-6)
|
|
{
|
|
tdp /= t;
|
|
tdp *= contact.normal.X;
|
|
}
|
|
else
|
|
tdp *= 10;
|
|
|
|
if (tdp > 0.25f)
|
|
tdp = 0.25f;
|
|
|
|
altContact.pos = contact.pos;
|
|
altContact.depth = tdp;
|
|
|
|
if (reverse)
|
|
{
|
|
altContact.normal = Unsafe.As<Vector3, UBOdeNative.Vector3>(ref offset);
|
|
}
|
|
else
|
|
{
|
|
altContact.normal.X = -offset.X;
|
|
altContact.normal.Y = -offset.Y;
|
|
altContact.normal.Z = -offset.Z;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called from Simulate
|
|
/// This is the avatar's movement control + PID Controller
|
|
/// </summary>
|
|
/// <param name="timeStep"></param>
|
|
public void Move()
|
|
{
|
|
if (Body == IntPtr.Zero)
|
|
return;
|
|
|
|
if (!UBOdeNative.BodyIsEnabled(Body))
|
|
{
|
|
if (++m_bodydisablecontrol < 50)
|
|
return;
|
|
|
|
// clear residuals
|
|
UBOdeNative.BodySetAngularVel(Body, 0f, 0f, 0f);
|
|
UBOdeNative.BodySetLinearVel(Body, 0f, 0f, 0f);
|
|
_zeroFlag = true;
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
|
|
m_bodydisablecontrol = 0;
|
|
|
|
// the Amotor still lets avatar rotation to drift during colisions
|
|
// so force it back to identity
|
|
UBOdeNative.BodySetQuaternion(Body, ref m_NativeOrientation2D);
|
|
|
|
_position = UBOdeNative.BodyGetPositionOMV(Body);
|
|
// check outbounds forcing to be in world
|
|
bool fixbody = false;
|
|
if ((Single.IsNaN(_position.X) || Single.IsInfinity(_position.X)))
|
|
{
|
|
fixbody = true;
|
|
_position.X = 128f;
|
|
}
|
|
else if (_position.X < 0.0f)
|
|
{
|
|
fixbody = true;
|
|
_position.X = 0.1f;
|
|
}
|
|
else if (_position.X > m_parent_scene.WorldExtents.X - 0.1f)
|
|
{
|
|
fixbody = true;
|
|
_position.X = m_parent_scene.WorldExtents.X - 0.1f;
|
|
}
|
|
|
|
if ((Single.IsNaN(_position.Y) || Single.IsInfinity(_position.Y)))
|
|
{
|
|
fixbody = true;
|
|
_position.Y = 128f;
|
|
}
|
|
else if (_position.Y < 0.0f)
|
|
{
|
|
fixbody = true;
|
|
_position.Y = 0.1f;
|
|
}
|
|
else if (_position.Y > m_parent_scene.WorldExtents.Y - 0.1f)
|
|
{
|
|
fixbody = true;
|
|
_position.Y = m_parent_scene.WorldExtents.Y - 0.1f;
|
|
}
|
|
|
|
if ((Single.IsNaN(_position.Z) || Single.IsInfinity(_position.Z)))
|
|
{
|
|
fixbody = true;
|
|
_position.Z = 128f;
|
|
}
|
|
|
|
if (fixbody)
|
|
{
|
|
m_freemove = false;
|
|
UBOdeNative.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
|
|
}
|
|
|
|
if (!m_pidControllerActive)
|
|
_zeroPosition = _position;
|
|
|
|
//Update AABB
|
|
UpdateAABB2D();
|
|
|
|
float aabbminz = _position.Z - CapsuleSizeZ;
|
|
//float aabbmaxz = _position.Z + CapsuleSizeZ;
|
|
|
|
bool tviszero = m_targetVelocity.IsZero();
|
|
|
|
Vector3 ctv;
|
|
if (tviszero)
|
|
ctv = Vector3.Zero;
|
|
else
|
|
{
|
|
if (m_alwaysRun)
|
|
{
|
|
ctv = new( m_targetVelocity.X * m_runMultiplier,
|
|
m_targetVelocity.Y * m_runMultiplier,
|
|
m_targetVelocity.Z);
|
|
}
|
|
else
|
|
{
|
|
ctv = new ( m_targetVelocity.X * m_walkMultiplier,
|
|
m_targetVelocity.Y * m_walkMultiplier,
|
|
m_targetVelocity.Z);
|
|
}
|
|
}
|
|
|
|
Vector3 vel = UBOdeNative.BodyGetLinearVelOMV(Body);
|
|
|
|
//******************************************
|
|
// colide with land
|
|
float tmpX = _position.X;
|
|
float tmpY = _position.Y;
|
|
if (m_flying)
|
|
{
|
|
tmpX += vel.X * m_sceneTimeStep;
|
|
tmpY += vel.Y * m_sceneTimeStep;
|
|
}
|
|
|
|
Vector3 vec = Vector3.Zero;
|
|
float terrainheight = m_parent_scene.GetTerrainHeightAtXY(tmpX, tmpY);
|
|
if (aabbminz < terrainheight)
|
|
{
|
|
if (ctv.Z < 0f)
|
|
ctv.Z = 0f;
|
|
|
|
if (!m_haveLastFallVel)
|
|
{
|
|
m_lastFallVel = vel;
|
|
m_haveLastFallVel = true;
|
|
}
|
|
|
|
float pidp50 = PID_P * 50;
|
|
float depth = terrainheight - aabbminz;
|
|
vec.Z = depth * pidp50;
|
|
|
|
Vector3 n = m_parent_scene.GetTerrainNormalAtXY(tmpX, tmpY);
|
|
if (!m_flying)
|
|
{
|
|
vec.Z -= vel.Z * PID_D;
|
|
|
|
if (n.Z < 0.4f)
|
|
{
|
|
vec.X = depth * pidp50 - vel.X * PID_D;
|
|
vec.X *= n.X;
|
|
vec.Y = depth * pidp50 - vel.Y * PID_D;
|
|
vec.Y *= n.Y;
|
|
vec.Z *= n.Z;
|
|
if (n.Z < 0.1f)
|
|
{
|
|
// cancel the slope pose
|
|
n.X = 0f;
|
|
n.Y = 0f;
|
|
n.Z = 1.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (depth < 0.2f)
|
|
{
|
|
m_colliderGroundfilter++;
|
|
if (m_colliderGroundfilter > 2)
|
|
{
|
|
m_iscolliding = true;
|
|
Colliderfilter = 2;
|
|
|
|
if (m_colliderGroundfilter > 10)
|
|
{
|
|
m_colliderGroundfilter = 10;
|
|
m_freemove = false;
|
|
}
|
|
|
|
CollideNormal = n;
|
|
|
|
m_iscollidingGround = true;
|
|
|
|
ContactPoint contact = new()
|
|
{
|
|
PenetrationDepth = depth,
|
|
Position = new( _position.X, _position.Y, terrainheight),
|
|
SurfaceNormal = -n,
|
|
RelativeSpeed = Vector3.Dot(m_lastFallVel, n),
|
|
CharacterFeet = true
|
|
};
|
|
AddCollisionEvent(0,contact);
|
|
m_lastFallVel = Vector3.Zero;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
m_colliderGroundfilter -= 5;
|
|
if (m_colliderGroundfilter <= 0)
|
|
{
|
|
m_colliderGroundfilter = 0;
|
|
m_iscollidingGround = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_haveLastFallVel = false;
|
|
m_colliderGroundfilter -= 5;
|
|
if (m_colliderGroundfilter <= 0)
|
|
{
|
|
m_colliderGroundfilter = 0;
|
|
m_iscollidingGround = false;
|
|
}
|
|
}
|
|
|
|
bool hoverPIDActive = false;
|
|
|
|
if (m_useHoverPID && m_PIDHoverTau != 0 && m_PIDHoverHeight != 0)
|
|
{
|
|
hoverPIDActive = true;
|
|
|
|
switch (m_PIDHoverType)
|
|
{
|
|
case PIDHoverType.Ground:
|
|
m_targetHoverHeight = terrainheight + m_PIDHoverHeight;
|
|
break;
|
|
|
|
case PIDHoverType.GroundAndWater:
|
|
if (terrainheight > m_parent_scene.WaterLevel)
|
|
m_targetHoverHeight = terrainheight + m_PIDHoverHeight;
|
|
else
|
|
m_targetHoverHeight = m_parent_scene.WaterLevel + m_PIDHoverHeight;
|
|
break;
|
|
} // end switch (m_PIDHoverType)
|
|
|
|
// don't go underground
|
|
if (m_targetHoverHeight > terrainheight + _position.Z)
|
|
{
|
|
float fz = (m_targetHoverHeight - _position.Z);
|
|
|
|
// if error is zero, use position control; otherwise, velocity control
|
|
if (MathF.Abs(fz) < 0.01f)
|
|
{
|
|
ctv.Z = 0;
|
|
}
|
|
else
|
|
{
|
|
_zeroFlag = false;
|
|
fz /= m_PIDHoverTau;
|
|
|
|
float tmp = MathF.Abs(fz);
|
|
if (tmp > 50f)
|
|
fz = 50f * MathF.Sign(fz);
|
|
else if (tmp < 0.1f)
|
|
fz = 0.1f * MathF.Sign(fz);
|
|
|
|
ctv.Z = fz;
|
|
}
|
|
}
|
|
}
|
|
|
|
//******************************************
|
|
if (!m_iscolliding)
|
|
CollideNormal.Z = 0;
|
|
|
|
if (!tviszero)
|
|
{
|
|
m_freemove = false;
|
|
|
|
// movement relative to surface if moving on it
|
|
// dont disturbe vertical movement, ie jumps
|
|
if (m_iscolliding && !m_flying && ctv.Z == 0f && CollideNormal.Z > 0.2f && CollideNormal.Z < 0.94f)
|
|
{
|
|
float p = ctv.X * CollideNormal.X + ctv.Y * CollideNormal.Y;
|
|
ctv.X *= MathF.Sqrt(1 - CollideNormal.X * CollideNormal.X);
|
|
ctv.Y *= MathF.Sqrt(1 - CollideNormal.Y * CollideNormal.Y);
|
|
ctv.Z -= p;
|
|
if (ctv.Z < 0f)
|
|
ctv.Z *= 2f;
|
|
}
|
|
}
|
|
|
|
float breakfactor;
|
|
if (!m_freemove)
|
|
{
|
|
// if velocity is zero, use position control; otherwise, velocity control
|
|
if (tviszero)
|
|
{
|
|
if (m_iscolliding || m_flying)
|
|
{
|
|
// keep track of where we stopped. No more slippin' & slidin'
|
|
if (!_zeroFlag)
|
|
{
|
|
_zeroFlag = true;
|
|
_zeroPosition = _position;
|
|
if(!m_pidControllerActive)
|
|
{
|
|
float pidd0833 = PID_D * 0.833f;
|
|
vec.X -= vel.X * pidd0833;
|
|
vec.Y -= vel.Y * pidd0833;
|
|
}
|
|
}
|
|
if (m_pidControllerActive)
|
|
{
|
|
// We only want to deactivate the PID Controller if we think we want to have our surrogate
|
|
// react to the physics scene by moving it's position.
|
|
// Avatar to Avatar collisions
|
|
// Prim to avatar collisions
|
|
float pidd2 = PID_D * 2f;
|
|
float pidp5 = PID_P * 5;
|
|
|
|
vec.X = -vel.X * pidd2 + (_zeroPosition.X - _position.X) * pidp5;
|
|
vec.Y = -vel.Y * pidd2 + (_zeroPosition.Y - _position.Y) * pidp5;
|
|
if (vel.Z > 0)
|
|
vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - _position.Z) * PID_P;
|
|
else
|
|
vec.Z += (-vel.Z * PID_D + (_zeroPosition.Z - _position.Z) * PID_P) * 0.2f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_zeroFlag = false;
|
|
float pidd0833 = PID_D * 0.833f;
|
|
vec.X += (ctv.X - vel.X) * pidd0833;
|
|
vec.Y += (ctv.Y - vel.Y) * pidd0833;
|
|
// hack for breaking on fall
|
|
if (ctv.Z == -9999f)
|
|
vec.Z += -vel.Z * PID_D - m_scenegravityForceZ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pidControllerActive = true;
|
|
_zeroFlag = false;
|
|
|
|
if (m_iscolliding)
|
|
{
|
|
if (!m_flying)
|
|
{
|
|
// we are on a surface
|
|
if (ctv.Z > 0f)
|
|
{
|
|
// moving up or JUMPING
|
|
vec.Z += (ctv.Z - vel.Z) * PID_D * 2f;
|
|
vec.X += (ctv.X - vel.X) * PID_D;
|
|
vec.Y += (ctv.Y - vel.Y) * PID_D;
|
|
}
|
|
else
|
|
{
|
|
// we are moving down on a surface
|
|
if (ctv.Z == 0)
|
|
{
|
|
if (vel.Z > 0)
|
|
vec.Z -= vel.Z * PID_D * 2f;
|
|
vec.X += (ctv.X - vel.X) * PID_D;
|
|
vec.Y += (ctv.Y - vel.Y) * PID_D;
|
|
}
|
|
// intencionally going down
|
|
else
|
|
{
|
|
if (ctv.Z < vel.Z)
|
|
vec.Z += (ctv.Z - vel.Z) * PID_D;
|
|
else
|
|
{
|
|
}
|
|
|
|
if (MathF.Abs(ctv.X) > MathF.Abs(vel.X))
|
|
vec.X += (ctv.X - vel.X) * PID_D;
|
|
if (MathF.Abs(ctv.Y) > MathF.Abs(vel.Y))
|
|
vec.Y += (ctv.Y - vel.Y) * PID_D;
|
|
}
|
|
}
|
|
|
|
// We're standing on something
|
|
}
|
|
else
|
|
{
|
|
// We're flying and colliding with something
|
|
float pidd00625 = PID_D * 0.0625f;
|
|
vec.X += (ctv.X - vel.X) * pidd00625;
|
|
vec.Y += (ctv.Y - vel.Y) * pidd00625;
|
|
vec.Z += (ctv.Z - vel.Z) * pidd00625;
|
|
}
|
|
}
|
|
else // ie not colliding
|
|
{
|
|
if (m_flying || hoverPIDActive) //(!m_iscolliding && flying)
|
|
{
|
|
// we're in mid air suspended
|
|
vec.X += (ctv.X - vel.X) * PID_D;
|
|
vec.Y += (ctv.Y - vel.Y) * PID_D;
|
|
vec.Z += (ctv.Z - vel.Z) * PID_D;
|
|
}
|
|
|
|
else
|
|
{
|
|
// we're not colliding and we're not flying so that means we're falling!
|
|
// m_iscolliding includes collisions with the ground.
|
|
|
|
// d.Vector3 pos = d.BodyGetPosition(Body);
|
|
float pidd0833 = PID_D * 0.833f;
|
|
vec.X += (ctv.X - vel.X) * pidd0833;
|
|
vec.Y += (ctv.Y - vel.Y) * pidd0833;
|
|
// hack for breaking on fall
|
|
if (ctv.Z == -9999f)
|
|
vec.Z += -vel.Z * PID_D - m_scenegravityForceZ;
|
|
}
|
|
}
|
|
}
|
|
float velLengthSquared = vel.LengthSquared();
|
|
if (velLengthSquared > 2500.0f) // 50m/s apply breaks
|
|
{
|
|
breakfactor = 0.16f * m_mass;
|
|
vec.X -= breakfactor * vel.X;
|
|
vec.Y -= breakfactor * vel.Y;
|
|
vec.Z -= breakfactor * vel.Z;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
breakfactor = m_mass;
|
|
vec.X -= breakfactor * vel.X;
|
|
vec.Y -= breakfactor * vel.Y;
|
|
if (m_flying)
|
|
vec.Z -= 0.5f * breakfactor * vel.Z;
|
|
else
|
|
vec.Z -= .16f * m_mass * vel.Z;
|
|
}
|
|
|
|
if (m_flying || hoverPIDActive)
|
|
{
|
|
vec.Z -= m_scenegravityForceZ;
|
|
|
|
if (!hoverPIDActive)
|
|
{
|
|
//Added for auto fly height. Kitto Flora
|
|
float target_altitude = terrainheight + MinimumGroundFlightOffset;
|
|
|
|
if (_position.Z < target_altitude)
|
|
{
|
|
vec.Z += (target_altitude - _position.Z) * PID_P * 5.0f;
|
|
}
|
|
// end add Kitto Flora
|
|
}
|
|
}
|
|
else if (m_buoyancy != 0.0)
|
|
{
|
|
vec.Z -= m_scenegravityForceZ * m_buoyancy;
|
|
}
|
|
|
|
if ((vec.Z != 0 || vec.X != 0 || vec.Y != 0))
|
|
UBOdeNative.BodyAddForce(Body, vec.X, vec.Y, vec.Z);
|
|
|
|
if (_zeroFlag)
|
|
{
|
|
_velocity = Vector3.Zero;
|
|
_acceleration = Vector3.Zero;
|
|
m_rotationalVelocity = Vector3.Zero;
|
|
}
|
|
else
|
|
{
|
|
Vector3 a = _velocity; // previous velocity
|
|
SetSmooth(ref _velocity, ref vel, 2);
|
|
a = (_velocity - a) * m_sceneInverseTimeStep;
|
|
SetSmooth(ref _acceleration, ref a, 2);
|
|
|
|
m_rotationalVelocity = UBOdeNative.BodyGetAngularVelOMVforAvatar(Body);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void round(ref Vector3 v, int digits)
|
|
{
|
|
v.X = MathF.Round(v.X, digits);
|
|
v.Y = MathF.Round(v.Y, digits);
|
|
v.Z = MathF.Round(v.Z, digits);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void SetSmooth(ref Vector3 dst, ref Vector3 value, int rounddigits)
|
|
{
|
|
dst.X = 0.4f * dst.X + 0.6f * value.X;
|
|
dst.X = MathF.Round(dst.X, rounddigits);
|
|
|
|
dst.Y = 0.4f * dst.Y + 0.6f * value.Y;
|
|
dst.Y = MathF.Round(dst.Y, rounddigits);
|
|
|
|
dst.Z = 0.4f * dst.Z + 0.6f * value.Z;
|
|
dst.Z = MathF.Round(dst.Z, rounddigits);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the reported position and velocity.
|
|
/// Used to copy variables from unmanaged space at heartbeat rate and also trigger scene updates acording
|
|
/// also outbounds checking
|
|
/// copy and outbounds now done in move(..) at ode rate
|
|
///
|
|
/// </summary>
|
|
/*
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void UpdatePositionAndVelocity()
|
|
{
|
|
}
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Cleanup the things we use in the scene.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void Destroy()
|
|
{
|
|
AddChange(changes.Remove, null);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void CrossingFailure()
|
|
{
|
|
}
|
|
|
|
public override Vector3 PIDTarget
|
|
{
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
public override bool PIDActive
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_pidControllerActive;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
public override float PIDTau
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override float PIDHoverHeight
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
AddChange(changes.PIDHoverHeight, value);
|
|
}
|
|
}
|
|
public override bool PIDHoverActive
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get
|
|
{
|
|
return m_useHoverPID;
|
|
}
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
AddChange(changes.PIDHoverActive, value);
|
|
}
|
|
}
|
|
|
|
public override PIDHoverType PIDHoverType
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
AddChange(changes.PIDHoverType, value);
|
|
}
|
|
}
|
|
|
|
public override float PIDHoverTau
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
float tmp = 0;
|
|
if (value > 0)
|
|
{
|
|
float mint = m_sceneTimeStep < 0.05f ? 0.05f : m_sceneTimeStep;
|
|
tmp = value < mint ? mint : value;
|
|
}
|
|
AddChange(changes.PIDHoverTau, tmp);
|
|
}
|
|
}
|
|
|
|
public override Quaternion APIDTarget
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override bool APIDActive
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override float APIDStrength
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public override float APIDDamping
|
|
{
|
|
set
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void SubscribeEvents(int ms)
|
|
{
|
|
m_eventsubscription = ms;
|
|
m_cureventsubscription = 0;
|
|
CollisionEventsThisFrame.Clear();
|
|
SentEmptyCollisionsEvent = false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void UnSubscribeEvents()
|
|
{
|
|
m_eventsubscription = 0;
|
|
m_parent_scene.RemoveCollisionEventReporting(this);
|
|
lock (CollisionEventsThisFrame)
|
|
CollisionEventsThisFrame.Clear();
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
|
|
{
|
|
lock (CollisionEventsThisFrame)
|
|
CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
|
|
m_parent_scene.AddCollisionEventReporting(this);
|
|
}
|
|
|
|
public void SendCollisions(int timestep)
|
|
{
|
|
if (m_cureventsubscription < 50000)
|
|
m_cureventsubscription += timestep;
|
|
|
|
if (m_cureventsubscription < m_eventsubscription)
|
|
return;
|
|
|
|
if (Body != IntPtr.Zero && !UBOdeNative.BodyIsEnabled(Body))
|
|
return;
|
|
|
|
lock (CollisionEventsThisFrame)
|
|
{
|
|
int ncolisions = CollisionEventsThisFrame.m_objCollisionList.Count;
|
|
|
|
if (!SentEmptyCollisionsEvent || ncolisions > 0)
|
|
{
|
|
base.SendCollisionUpdate(CollisionEventsThisFrame);
|
|
m_cureventsubscription = 0;
|
|
|
|
if (ncolisions == 0)
|
|
{
|
|
SentEmptyCollisionsEvent = true;
|
|
//_parent_scene.RemoveCollisionEventReporting(this);
|
|
}
|
|
else
|
|
{
|
|
SentEmptyCollisionsEvent = false;
|
|
CollisionEventsThisFrame.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override bool SubscribedEvents()
|
|
{
|
|
if (m_eventsubscription > 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePhysicsStatus(bool NewStatus)
|
|
{
|
|
if (NewStatus != m_isPhysical)
|
|
{
|
|
if (NewStatus)
|
|
{
|
|
AvatarGeomAndBodyDestroy();
|
|
AvatarGeomAndBodyCreate();
|
|
|
|
m_parent_scene.actor_name_map[collider] = this;
|
|
m_parent_scene.AddCharacter(this);
|
|
}
|
|
else
|
|
{
|
|
m_parent_scene.RemoveCollisionEventReporting(this);
|
|
m_parent_scene.RemoveCharacter(this);
|
|
// destroy avatar capsule and related ODE data
|
|
AvatarGeomAndBodyDestroy();
|
|
}
|
|
m_freemove = false;
|
|
m_isPhysical = NewStatus;
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeAdd()
|
|
{
|
|
changePhysicsStatus(true);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeRemove()
|
|
{
|
|
changePhysicsStatus(false);
|
|
}
|
|
|
|
/*
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeShape(PrimitiveBaseShape arg)
|
|
{
|
|
}
|
|
*/
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeAvatarSize(strAvatarSize st)
|
|
{
|
|
changeSize(st.size);
|
|
}
|
|
|
|
private void changeSize(Vector3 pSize)
|
|
{
|
|
if (pSize.IsFinite())
|
|
{
|
|
// for now only look to Z changes since viewers also don't change X and Y
|
|
if (pSize.Z != m_size.Z)
|
|
{
|
|
float oldsz = m_size.Z;
|
|
m_size = pSize * 0.5f;
|
|
|
|
float sz = m_size.Z;
|
|
|
|
float bot = -sz;
|
|
boneOff = bot + 0.3f;
|
|
|
|
float feetsz = sz * 0.9f;
|
|
if (feetsz > 0.6f)
|
|
feetsz = 0.6f;
|
|
feetOff = bot + feetsz;
|
|
|
|
float sx = m_size.X;
|
|
AvaSizeXsq = sx;
|
|
AvaSizeXsq *= AvaSizeXsq;
|
|
|
|
float sy = m_size.Y;
|
|
AvaSizeYsq = sy;
|
|
AvaSizeYsq *= AvaSizeYsq;
|
|
|
|
CapsuleRadius = MathF.Max(sx, sy);
|
|
float l = sz - CapsuleRadius;
|
|
CapsuleSizeZ= sz;
|
|
|
|
UBOdeNative.GeomCapsuleSetParams(collider, CapsuleRadius, 2f * l);
|
|
|
|
m_mass = 8f * m_density * sx * sy * sz; // update mass
|
|
m_massInvTimeScaled = m_mass * m_sceneInverseTimeStep;
|
|
PID_D = basePID_D * m_massInvTimeScaled;
|
|
PID_P = basePID_P * m_massInvTimeScaled;
|
|
UBOdeNative.MassSetBoxTotal(out ShellMass, m_mass, 2f * sx, 2f * sy, 2f * sz);
|
|
UBOdeNative.BodySetMass(Body, ref ShellMass);
|
|
|
|
m_scenegravityForceZ = m_parent_scene.gravityz * m_mass;
|
|
|
|
_position.Z += sz - oldsz;
|
|
UBOdeNative.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
|
|
|
|
UpdateAABB2D();
|
|
|
|
m_bodydisablecontrol = 0;
|
|
_zeroFlag = false;
|
|
_velocity = Vector3.Zero;
|
|
m_targetVelocity = Vector3.Zero;
|
|
}
|
|
m_freemove = false;
|
|
m_pidControllerActive = true;
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePosition(Vector3 newPos)
|
|
{
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
UBOdeNative.BodySetPosition(Body, newPos.X, newPos.Y, newPos.Z);
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
_position = newPos;
|
|
UpdateAABB2D();
|
|
|
|
m_freemove = false;
|
|
_zeroFlag = false;
|
|
m_pidControllerActive = true;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeOrientation(Quaternion newOri)
|
|
{
|
|
if (m_orientation.NotEqual(newOri))
|
|
{
|
|
|
|
m_orientation = newOri;
|
|
Orientation2D.X = newOri.Z;
|
|
Orientation2D.Y = newOri.W;
|
|
Orientation2D.Normalize();
|
|
|
|
m_NativeOrientation2D.X = 0;
|
|
m_NativeOrientation2D.Y = 0;
|
|
m_NativeOrientation2D.Z = Orientation2D.X;
|
|
m_NativeOrientation2D.W = Orientation2D.Y;
|
|
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
UBOdeNative.BodySetQuaternion(Body, ref m_NativeOrientation2D);
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
}
|
|
else if (Body != IntPtr.Zero)
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeVelocity(Vector3 newVel)
|
|
{
|
|
_velocity = newVel;
|
|
setFreeMove();
|
|
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
UBOdeNative.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeTargetVelocity(Vector3 newVel)
|
|
{
|
|
//m_pidControllerActive = true;
|
|
//m_freemove = false;
|
|
m_targetVelocity = newVel;
|
|
if (Body != IntPtr.Zero)
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
/*
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeSetTorque(Vector3 newTorque)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeAddForce(Vector3 newForce)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeAddAngularForce(Vector3 arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeAngularLock(byte arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeFloatOnWater(bool arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeVolumedetetion(bool arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeSelectedStatus(bool arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeDisable(bool arg)
|
|
{
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeBuilding(bool arg)
|
|
{
|
|
}
|
|
*/
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void setFreeMove()
|
|
{
|
|
m_pidControllerActive = true;
|
|
_zeroFlag = false;
|
|
m_targetVelocity = Vector3.Zero;
|
|
m_freemove = true;
|
|
Colliderfilter = int.MinValue;
|
|
m_colliderObjectfilter = -1;
|
|
m_colliderGroundfilter = -1;
|
|
|
|
m_iscolliding = false;
|
|
m_iscollidingGround = false;
|
|
m_iscollidingObj = false;
|
|
|
|
CollisionEventsThisFrame.Clear();
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeForce(Vector3 newForce)
|
|
{
|
|
setFreeMove();
|
|
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
if (newForce.X != 0f || newForce.Y != 0f || newForce.Z != 0)
|
|
UBOdeNative.BodyAddForce(Body, newForce.X, newForce.Y, newForce.Z);
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
}
|
|
|
|
// for now momentum is actually velocity
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changeMomentum(Vector3 newmomentum)
|
|
{
|
|
_velocity = newmomentum;
|
|
setFreeMove();
|
|
|
|
if (Body != IntPtr.Zero)
|
|
{
|
|
UBOdeNative.BodySetLinearVel(Body, newmomentum.X, newmomentum.Y, newmomentum.Z);
|
|
UBOdeNative.BodyEnable(Body);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePIDHoverHeight(float val)
|
|
{
|
|
m_PIDHoverHeight = val;
|
|
if (val == 0)
|
|
m_useHoverPID = false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePIDHoverType(PIDHoverType type)
|
|
{
|
|
m_PIDHoverType = type;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePIDHoverTau(float tau)
|
|
{
|
|
m_PIDHoverTau = tau;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void changePIDHoverActive(bool active)
|
|
{
|
|
m_useHoverPID = active;
|
|
}
|
|
|
|
/*
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private void donullchange()
|
|
{
|
|
}
|
|
*/
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void UpdateAABB2D()
|
|
{
|
|
_AABB2D.minx = _position.X - CapsuleRadius;
|
|
_AABB2D.maxx = _position.X + CapsuleRadius;
|
|
_AABB2D.miny = _position.Y - CapsuleRadius;
|
|
_AABB2D.maxy = _position.Y + CapsuleRadius;
|
|
}
|
|
|
|
public bool DoAChange(changes what, object arg)
|
|
{
|
|
if (collider == IntPtr.Zero && what != changes.Add && what != changes.Remove)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (what)
|
|
{
|
|
case changes.Add:
|
|
changeAdd();
|
|
break;
|
|
case changes.Remove:
|
|
changeRemove();
|
|
break;
|
|
|
|
case changes.Position:
|
|
changePosition((Vector3)arg);
|
|
break;
|
|
|
|
case changes.Orientation:
|
|
changeOrientation((Quaternion)arg);
|
|
break;
|
|
|
|
/*
|
|
case changes.PosOffset:
|
|
donullchange();
|
|
break;
|
|
|
|
case changes.OriOffset:
|
|
donullchange();
|
|
break;
|
|
*/
|
|
case changes.Velocity:
|
|
changeVelocity((Vector3)arg);
|
|
break;
|
|
|
|
case changes.TargetVelocity:
|
|
changeTargetVelocity((Vector3)arg);
|
|
break;
|
|
|
|
/*
|
|
case changes.Acceleration:
|
|
changeacceleration((Vector3)arg);
|
|
break;
|
|
|
|
case changes.AngVelocity:
|
|
changeangvelocity((Vector3)arg);
|
|
break;
|
|
*/
|
|
case changes.Force:
|
|
changeForce((Vector3)arg);
|
|
break;
|
|
/*
|
|
case changes.Torque:
|
|
changeSetTorque((Vector3)arg);
|
|
break;
|
|
|
|
case changes.AddForce:
|
|
changeAddForce((Vector3)arg);
|
|
break;
|
|
|
|
case changes.AddAngForce:
|
|
changeAddAngularForce((Vector3)arg);
|
|
break;
|
|
|
|
case changes.AngLock:
|
|
changeAngularLock((byte)arg);
|
|
break;
|
|
*/
|
|
case changes.Size:
|
|
changeSize((Vector3)arg);
|
|
break;
|
|
|
|
case changes.AvatarSize:
|
|
changeAvatarSize((strAvatarSize)arg);
|
|
break;
|
|
|
|
case changes.Momentum:
|
|
changeMomentum((Vector3)arg);
|
|
break;
|
|
|
|
case changes.PIDHoverHeight:
|
|
changePIDHoverHeight((float)arg);
|
|
break;
|
|
|
|
case changes.PIDHoverType:
|
|
changePIDHoverType((PIDHoverType)arg);
|
|
break;
|
|
|
|
case changes.PIDHoverTau:
|
|
changePIDHoverTau((float)arg);
|
|
break;
|
|
|
|
case changes.PIDHoverActive:
|
|
changePIDHoverActive((bool)arg);
|
|
break;
|
|
|
|
/*
|
|
case changes.Shape:
|
|
changeShape((PrimitiveBaseShape)arg);
|
|
break;
|
|
|
|
case changes.CollidesWater:
|
|
changeFloatOnWater((bool)arg);
|
|
break;
|
|
|
|
case changes.VolumeDtc:
|
|
changeVolumedetetion((bool)arg);
|
|
break;
|
|
*/
|
|
case changes.Physical:
|
|
changePhysicsStatus((bool)arg);
|
|
break;
|
|
/*
|
|
case changes.Selected:
|
|
changeSelectedStatus((bool)arg);
|
|
break;
|
|
|
|
case changes.disabled:
|
|
changeDisable((bool)arg);
|
|
break;
|
|
|
|
case changes.building:
|
|
changeBuilding((bool)arg);
|
|
break;
|
|
*/
|
|
//case changes.Null:
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void AddChange(changes what, object arg)
|
|
{
|
|
m_parent_scene.AddChange(this, what, arg);
|
|
}
|
|
|
|
private struct strAvatarSize
|
|
{
|
|
public Vector3 size;
|
|
}
|
|
}
|
|
}
|