/* * 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.Physics.Manager { 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, Water = 4 } public enum PIDHoverType { Ground, GroundAndWater, Water, Absolute } public struct ContactPoint { public Vector3 Position; public Vector3 SurfaceNormal; public float PenetrationDepth; public float RelativeSpeed; public bool CharacterFeet; public ContactPoint(Vector3 position, Vector3 surfaceNormal, float penetrationDepth) { Position = position; SurfaceNormal = surfaceNormal; PenetrationDepth = penetrationDepth; RelativeSpeed = 0f; // for now let this one be set explicity CharacterFeet = true; // keep other plugins work as before } public ContactPoint(Vector3 position, Vector3 surfaceNormal, float penetrationDepth, bool feet) { Position = position; SurfaceNormal = surfaceNormal; PenetrationDepth = penetrationDepth; RelativeSpeed = 0f; // for now let this one be set explicity CharacterFeet = feet; // keep other plugins work as before } } public struct ContactData { public float mu; public float bounce; public bool softcolide; public ContactData(float _mu, float _bounce, bool _softcolide) { mu = _mu; bounce = _bounce; softcolide = _softcolide; } } /// /// 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 virtual void SetVehicle(object vdata) { } public event OutOfBounds OnOutOfBounds; #pragma warning restore 67 public static PhysicsActor Null { get { return new NullPhysicsActor(); } } public virtual bool Building { get; set; } public virtual void getContactData(ref ContactData cdata) { cdata.mu = 0; cdata.bounce = 0; } public abstract bool Stopped { get; } public abstract Vector3 Size { get; set; } public virtual void setAvatarSize(Vector3 size, float feetOffset) { Size = size; } public virtual bool Phantom { get; set; } public virtual bool IsVolumeDtc { get { return false; } set { return; } } 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; 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; } public virtual Vector3 OOBsize { get { Vector3 s=Size; s.X *=0.5f; s.Y *=0.5f; s.Z *=0.5f; return s; } } public virtual Vector3 OOBoffset { get { return Vector3.Zero; } } public virtual float OOBRadiusSQ { get { return Size.LengthSquared() * 0.25f; // ((0.5^2) } } public virtual float PhysicsCost { get { return 0.1f; } } public virtual float StreamCost { get { return 1.0f; } } /// /// 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 { 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(); public virtual void AddCollisionEvent(uint CollidedWith, ContactPoint contact) { } // Warning in a parent part it returns itself, not null public virtual PhysicsActor ParentActor { get { return this; } } // Extendable interface for new, physics engine specific operations public virtual object Extension(string pFunct, params object[] pParams) { throw new NotImplementedException(); } } public class NullPhysicsActor : PhysicsActor { private ActorTypes m_actorType = ActorTypes.Unknown; public override bool Stopped { get{ return true; } } public override Vector3 Position { get { return Vector3.Zero; } set { return; } } public override bool SetAlwaysRun { get { return false; } set { return; } } public override uint LocalID { get { return 0; } 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)m_actorType; } set { ActorTypes type = (ActorTypes)value; switch (type) { case ActorTypes.Ground: case ActorTypes.Water: m_actorType = type; break; default: m_actorType = ActorTypes.Unknown; break; } } } 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 { 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; } } }