From 134f86e8d5c414409631b25b8c6f0ee45fbd8631 Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Thu, 3 Nov 2016 21:44:39 +1000 Subject: Initial update to OpenSim 0.8.2.1 source code. --- .../PhysicsModules/SharedBase/PhysicsActor.cs | 584 +++++++++++++++++++++ 1 file changed, 584 insertions(+) create mode 100644 OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs (limited to 'OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs') diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs new file mode 100644 index 0000000..c04ff58 --- /dev/null +++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs @@ -0,0 +1,584 @@ +/* + * 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. + */ + +using log4net; +using System; +using System.Collections.Generic; +using System.Reflection; +using OpenSim.Framework; +using OpenMetaverse; + +namespace OpenSim.Region.PhysicsModules.SharedBase +{ + public delegate void PositionUpdate(Vector3 position); + public delegate void VelocityUpdate(Vector3 velocity); + public delegate void OrientationUpdate(Quaternion orientation); + + public enum ActorTypes : int + { + Unknown = 0, + Agent = 1, + Prim = 2, + Ground = 3 + } + + public enum PIDHoverType + { + Ground, + GroundAndWater, + Water, + Absolute + } + + public struct ContactPoint + { + public Vector3 Position; + public Vector3 SurfaceNormal; + public float PenetrationDepth; + + public ContactPoint(Vector3 position, Vector3 surfaceNormal, float penetrationDepth) + { + Position = position; + SurfaceNormal = surfaceNormal; + PenetrationDepth = penetrationDepth; + } + } + + /// + /// Used to pass collision information to OnCollisionUpdate listeners. + /// + public class CollisionEventUpdate : EventArgs + { + /// + /// Number of collision events in this update. + /// + public int Count { get { return m_objCollisionList.Count; } } + + public bool CollisionsOnPreviousFrame { get; private set; } + + public Dictionary m_objCollisionList; + + public CollisionEventUpdate(Dictionary objCollisionList) + { + m_objCollisionList = objCollisionList; + } + + public CollisionEventUpdate() + { + m_objCollisionList = new Dictionary(); + } + + public void AddCollider(uint localID, ContactPoint contact) + { + if (!m_objCollisionList.ContainsKey(localID)) + { + m_objCollisionList.Add(localID, contact); + } + else + { + if (m_objCollisionList[localID].PenetrationDepth < contact.PenetrationDepth) + m_objCollisionList[localID] = contact; + } + } + + /// + /// Clear added collision events. + /// + public void Clear() + { + m_objCollisionList.Clear(); + } + } + + public abstract class PhysicsActor + { +// private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); + + public delegate void RequestTerseUpdate(); + public delegate void CollisionUpdate(EventArgs e); + public delegate void OutOfBounds(Vector3 pos); + +// disable warning: public events +#pragma warning disable 67 + public event PositionUpdate OnPositionUpdate; + public event VelocityUpdate OnVelocityUpdate; + public event OrientationUpdate OnOrientationUpdate; + public event RequestTerseUpdate OnRequestTerseUpdate; + + /// + /// Subscribers to this event must synchronously handle the dictionary of collisions received, since the event + /// object is reused in subsequent physics frames. + /// + public event CollisionUpdate OnCollisionUpdate; + + public event OutOfBounds OnOutOfBounds; +#pragma warning restore 67 + + public static PhysicsActor Null + { + get { return new NullPhysicsActor(); } + } + + public abstract bool Stopped { get; } + + public abstract Vector3 Size { get; set; } + + public virtual byte PhysicsShapeType { get; set; } + + public abstract PrimitiveBaseShape Shape { set; } + + uint m_baseLocalID; + public virtual uint LocalID + { + set { m_baseLocalID = value; } + get { return m_baseLocalID; } + } + + public abstract bool Grabbed { set; } + + public abstract bool Selected { set; } + + /// + /// Name of this actor. + /// + /// + /// XXX: Bizarrely, this cannot be "Terrain" or "Water" right now unless it really is simulating terrain or + /// water. This is not a problem due to the formatting of names given by prims and avatars. + /// + public string Name { get; protected set; } + + /// + /// This is being used by ODE joint code. + /// + public string SOPName; + + public abstract void CrossingFailure(); + + public abstract void link(PhysicsActor obj); + + public abstract void delink(); + + public abstract void LockAngularMotion(Vector3 axis); + + public virtual void RequestPhysicsterseUpdate() + { + // Make a temporary copy of the event to avoid possibility of + // a race condition if the last subscriber unsubscribes + // immediately after the null check and before the event is raised. + RequestTerseUpdate handler = OnRequestTerseUpdate; + + if (handler != null) + { + handler(); + } + } + + public virtual void RaiseOutOfBounds(Vector3 pos) + { + // Make a temporary copy of the event to avoid possibility of + // a race condition if the last subscriber unsubscribes + // immediately after the null check and before the event is raised. + OutOfBounds handler = OnOutOfBounds; + + if (handler != null) + { + handler(pos); + } + } + + public virtual void SendCollisionUpdate(EventArgs e) + { + CollisionUpdate handler = OnCollisionUpdate; + +// m_log.DebugFormat("[PHYSICS ACTOR]: Sending collision for {0}", LocalID); + + if (handler != null) + handler(e); + } + + public virtual void SetMaterial (int material) { } + public virtual float Density { get; set; } + public virtual float GravModifier { get; set; } + public virtual float Friction { get; set; } + public virtual float Restitution { get; set; } + + /// + /// Position of this actor. + /// + /// + /// Setting this directly moves the actor to a given position. + /// Getting this retrieves the position calculated by physics scene updates, using factors such as velocity and + /// collisions. + /// + public abstract Vector3 Position { get; set; } + + public abstract float Mass { get; } + public abstract Vector3 Force { get; set; } + + public abstract int VehicleType { get; set; } + public abstract void VehicleFloatParam(int param, float value); + public abstract void VehicleVectorParam(int param, Vector3 value); + public abstract void VehicleRotationParam(int param, Quaternion rotation); + public abstract void VehicleFlags(int param, bool remove); + + /// + /// Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more + /// + public abstract void SetVolumeDetect(int param); + + public abstract Vector3 GeometricCenter { get; } + public abstract Vector3 CenterOfMass { get; } + + /// + /// The desired velocity of this actor. + /// + /// + /// Setting this provides a target velocity for physics scene updates. + /// Getting this returns the last set target. Fetch Velocity to get the current velocity. + /// + protected Vector3 m_targetVelocity; + public virtual Vector3 TargetVelocity + { + get { return m_targetVelocity; } + set { + m_targetVelocity = value; + Velocity = m_targetVelocity; + } + } + + public abstract Vector3 Velocity { get; set; } + + public abstract Vector3 Torque { get; set; } + public abstract float CollisionScore { get; set;} + public abstract Vector3 Acceleration { get; set; } + public abstract Quaternion Orientation { get; set; } + public abstract int PhysicsActorType { get; set; } + public abstract bool IsPhysical { get; set; } + public abstract bool Flying { get; set; } + public abstract bool SetAlwaysRun { get; set; } + public abstract bool ThrottleUpdates { get; set; } + public abstract bool IsColliding { get; set; } + public abstract bool CollidingGround { get; set; } + public abstract bool CollidingObj { get; set; } + public abstract bool FloatOnWater { set; } + public abstract Vector3 RotationalVelocity { get; set; } + public abstract bool Kinematic { get; set; } + public abstract float Buoyancy { get; set; } + + // Used for MoveTo + public abstract Vector3 PIDTarget { set; } + public abstract bool PIDActive { get; set; } + public abstract float PIDTau { set; } + + // Used for llSetHoverHeight and maybe vehicle height + // Hover Height will override MoveTo target's Z + public abstract bool PIDHoverActive { set;} + public abstract float PIDHoverHeight { set;} + public abstract PIDHoverType PIDHoverType { set;} + public abstract float PIDHoverTau { set;} + + // For RotLookAt + public abstract Quaternion APIDTarget { set;} + public abstract bool APIDActive { set;} + public abstract float APIDStrength { set;} + public abstract float APIDDamping { set;} + + public abstract void AddForce(Vector3 force, bool pushforce); + public abstract void AddAngularForce(Vector3 force, bool pushforce); + public abstract void SetMomentum(Vector3 momentum); + public abstract void SubscribeEvents(int ms); + public abstract void UnSubscribeEvents(); + public abstract bool SubscribedEvents(); + + // Extendable interface for new, physics engine specific operations + public virtual object Extension(string pFunct, params object[] pParams) + { + // A NOP of the physics engine does not implement this feature + return null; + } + } + + public class NullPhysicsActor : PhysicsActor + { + public override bool Stopped + { + get{ return false; } + } + + public override Vector3 Position + { + get { return Vector3.Zero; } + set { return; } + } + + public override bool SetAlwaysRun + { + get { return false; } + set { return; } + } + + public override uint LocalID + { + set { return; } + } + + public override bool Grabbed + { + set { return; } + } + + public override bool Selected + { + set { return; } + } + + public override float Buoyancy + { + get { return 0f; } + set { return; } + } + + public override bool FloatOnWater + { + set { return; } + } + + public override bool CollidingGround + { + get { return false; } + set { return; } + } + + public override bool CollidingObj + { + get { return false; } + set { return; } + } + + public override Vector3 Size + { + get { return Vector3.Zero; } + set { return; } + } + + public override float Mass + { + get { return 0f; } + } + + public override Vector3 Force + { + get { return Vector3.Zero; } + set { return; } + } + + 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 void SetMaterial(int material) + { + + } + + public override Vector3 CenterOfMass + { + get { return Vector3.Zero; } + } + + public override Vector3 GeometricCenter + { + get { return Vector3.Zero; } + } + + public override PrimitiveBaseShape Shape + { + set { return; } + } + + public override Vector3 Velocity + { + get { return Vector3.Zero; } + set { return; } + } + + public override Vector3 Torque + { + get { return Vector3.Zero; } + set { return; } + } + + public override float CollisionScore + { + get { return 0f; } + set { } + } + + public override void CrossingFailure() + { + } + + public override Quaternion Orientation + { + get { return Quaternion.Identity; } + set { } + } + + public override Vector3 Acceleration + { + get { return Vector3.Zero; } + set { } + } + + public override bool IsPhysical + { + get { return false; } + set { return; } + } + + public override bool Flying + { + get { return false; } + set { return; } + } + + public override bool ThrottleUpdates + { + get { return false; } + set { return; } + } + + public override bool IsColliding + { + get { return false; } + set { return; } + } + + public override int PhysicsActorType + { + get { return (int) ActorTypes.Unknown; } + set { return; } + } + + public override bool Kinematic + { + get { return true; } + set { return; } + } + + public override void link(PhysicsActor obj) + { + } + + public override void delink() + { + } + + public override void LockAngularMotion(Vector3 axis) + { + } + + public override void AddForce(Vector3 force, bool pushforce) + { + } + + public override void AddAngularForce(Vector3 force, bool pushforce) + { + + } + + public override Vector3 RotationalVelocity + { + get { return Vector3.Zero; } + set { return; } + } + + public override Vector3 PIDTarget { set { return; } } + + public override bool PIDActive + { + get { return false; } + set { return; } + } + + public override float PIDTau { set { return; } } + + public override float PIDHoverHeight { set { return; } } + public override bool PIDHoverActive { set { return; } } + public override PIDHoverType PIDHoverType { set { return; } } + public override float PIDHoverTau { set { return; } } + + public override Quaternion APIDTarget { set { return; } } + public override bool APIDActive { set { return; } } + public override float APIDStrength { set { return; } } + public override float APIDDamping { set { return; } } + + public override void SetMomentum(Vector3 momentum) + { + } + + public override void SubscribeEvents(int ms) + { + + } + public override void UnSubscribeEvents() + { + + } + public override bool SubscribedEvents() + { + return false; + } + } +} -- cgit v1.1