PhysicsScene.cs 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Reflection;
  30. using log4net;
  31. using Nini.Config;
  32. using OpenSim.Framework;
  33. using OpenMetaverse;
  34. namespace OpenSim.Region.PhysicsModules.SharedBase
  35. {
  36. public delegate void physicsCrash();
  37. public delegate void RaycastCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 normal);
  38. public delegate void RayCallback(List<ContactResult> list);
  39. public delegate void ProbeBoxCallback(List<ContactResult> list);
  40. public delegate void ProbeSphereCallback(List<ContactResult> list);
  41. public delegate void ProbePlaneCallback(List<ContactResult> list);
  42. public delegate void SitAvatarCallback(int status, uint partID, Vector3 offset, Quaternion Orientation);
  43. public delegate void JointMoved(PhysicsJoint joint);
  44. public delegate void JointDeactivated(PhysicsJoint joint);
  45. public delegate void JointErrorMessage(PhysicsJoint joint, string message); // this refers to an "error message due to a problem", not "amount of joint constraint violation"
  46. public enum RayFilterFlags : ushort
  47. {
  48. // the flags
  49. water = 0x01,
  50. land = 0x02,
  51. agent = 0x04,
  52. nonphysical = 0x08,
  53. physical = 0x10,
  54. phantom = 0x20,
  55. volumedtc = 0x40,
  56. // ray cast colision control (may only work for meshs)
  57. ContactsUnImportant = 0x2000,
  58. BackFaceCull = 0x4000,
  59. ClosestHit = 0x8000,
  60. // some combinations
  61. LSLPhantom = phantom | volumedtc,
  62. PrimsNonPhantom = nonphysical | physical,
  63. PrimsNonPhantomAgents = nonphysical | physical | agent,
  64. AllPrims = nonphysical | phantom | volumedtc | physical,
  65. AllButLand = agent | nonphysical | physical | phantom | volumedtc,
  66. ClosestAndBackCull = ClosestHit | BackFaceCull,
  67. All = 0x3f
  68. }
  69. public delegate void RequestAssetDelegate(UUID assetID, AssetReceivedDelegate callback);
  70. public delegate void AssetReceivedDelegate(AssetBase asset);
  71. /// <summary>
  72. /// Contact result from a raycast.
  73. /// </summary>
  74. public struct ContactResult
  75. {
  76. public Vector3 Pos;
  77. public float Depth;
  78. public uint ConsumerID;
  79. public Vector3 Normal;
  80. }
  81. public abstract class PhysicsScene
  82. {
  83. // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  84. /// <summary>
  85. /// A unique identifying string for this instance of the physics engine.
  86. /// Useful in debug messages to distinguish one OdeScene instance from another.
  87. /// Usually set to include the region name that the physics engine is acting for.
  88. /// </summary>
  89. public string PhysicsSceneName { get; protected set; }
  90. /// <summary>
  91. /// A string identifying the family of this physics engine. Most common values returned
  92. /// are "OpenDynamicsEngine" and "BulletSim" but others are possible.
  93. /// </summary>
  94. public string EngineType { get; protected set; }
  95. public string EngineName { get; protected set; }
  96. // The only thing that should register for this event is the SceneGraph
  97. // Anything else could cause problems.
  98. public event physicsCrash OnPhysicsCrash;
  99. public static PhysicsScene Null
  100. {
  101. get { return new NullPhysicsScene(); }
  102. }
  103. public RequestAssetDelegate RequestAssetMethod { get; set; }
  104. protected void Initialise(RequestAssetDelegate m, float[] terrain, float waterHeight)
  105. {
  106. RequestAssetMethod = m;
  107. SetTerrain(terrain);
  108. SetWaterLevel(waterHeight);
  109. }
  110. public virtual void TriggerPhysicsBasedRestart()
  111. {
  112. physicsCrash handler = OnPhysicsCrash;
  113. if (handler != null)
  114. {
  115. OnPhysicsCrash();
  116. }
  117. }
  118. /// <summary>
  119. /// Add an avatar
  120. /// </summary>
  121. /// <param name="avName"></param>
  122. /// <param name="position"></param>
  123. /// <param name="velocity"></param>
  124. /// <param name="size"></param>
  125. /// <param name="isFlying"></param>
  126. /// <returns></returns>
  127. public abstract PhysicsActor AddAvatar(
  128. string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying);
  129. /// <summary>
  130. /// Add an avatar
  131. /// </summary>
  132. /// <param name="localID"></param>
  133. /// <param name="avName"></param>
  134. /// <param name="position"></param>
  135. /// <param name="velocity"></param>
  136. /// <param name="size"></param>
  137. /// <param name="isFlying"></param>
  138. /// <returns></returns>
  139. public virtual PhysicsActor AddAvatar(
  140. uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
  141. {
  142. PhysicsActor ret = AddAvatar(avName, position, velocity, size, isFlying);
  143. if (ret != null)
  144. ret.LocalID = localID;
  145. return ret;
  146. }
  147. public virtual PhysicsActor AddAvatar(
  148. uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
  149. {
  150. PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);
  151. return ret;
  152. }
  153. public virtual PhysicsActor AddAvatar(
  154. uint localID, string avName, Vector3 position, Vector3 size, float feetOffset, bool isFlying)
  155. {
  156. PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);
  157. return ret;
  158. }
  159. /// <summary>
  160. /// Remove an avatar.
  161. /// </summary>
  162. /// <param name="actor"></param>
  163. public abstract void RemoveAvatar(PhysicsActor actor);
  164. /// <summary>
  165. /// Remove a prim.
  166. /// </summary>
  167. /// <param name="prim"></param>
  168. public abstract void RemovePrim(PhysicsActor prim);
  169. public abstract PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
  170. Vector3 size, Quaternion rotation, bool isPhysical, uint localid);
  171. public virtual PhysicsActor AddPrimShape(string primName, PhysicsActor parent, PrimitiveBaseShape pbs, Vector3 position,
  172. uint localid, byte[] sdata)
  173. {
  174. return null;
  175. }
  176. public virtual PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
  177. Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
  178. {
  179. return AddPrimShape(primName, pbs, position, size, rotation, isPhysical, localid);
  180. }
  181. public virtual PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
  182. Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapetype, uint localid)
  183. {
  184. return AddPrimShape(primName, pbs, position, size, rotation, isPhysical, localid);
  185. }
  186. public virtual float TimeDilation
  187. {
  188. get { return 1.0f; }
  189. }
  190. public virtual bool SupportsNINJAJoints
  191. {
  192. get { return false; }
  193. }
  194. public virtual PhysicsJoint RequestJointCreation(string objectNameInScene, PhysicsJointType jointType, Vector3 position,
  195. Quaternion rotation, string parms, List<string> bodyNames, string trackedBodyName, Quaternion localRotation)
  196. { return null; }
  197. public virtual void RequestJointDeletion(string objectNameInScene)
  198. { return; }
  199. public virtual void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
  200. { return; }
  201. public virtual void DumpJointInfo()
  202. { return; }
  203. public event JointMoved OnJointMoved;
  204. protected virtual void DoJointMoved(PhysicsJoint joint)
  205. {
  206. // We need this to allow subclasses (but not other classes) to invoke the event; C# does
  207. // not allow subclasses to invoke the parent class event.
  208. if (OnJointMoved != null)
  209. {
  210. OnJointMoved(joint);
  211. }
  212. }
  213. public event JointDeactivated OnJointDeactivated;
  214. protected virtual void DoJointDeactivated(PhysicsJoint joint)
  215. {
  216. // We need this to allow subclasses (but not other classes) to invoke the event; C# does
  217. // not allow subclasses to invoke the parent class event.
  218. if (OnJointDeactivated != null)
  219. {
  220. OnJointDeactivated(joint);
  221. }
  222. }
  223. public event JointErrorMessage OnJointErrorMessage;
  224. protected virtual void DoJointErrorMessage(PhysicsJoint joint, string message)
  225. {
  226. // We need this to allow subclasses (but not other classes) to invoke the event; C# does
  227. // not allow subclasses to invoke the parent class event.
  228. if (OnJointErrorMessage != null)
  229. {
  230. OnJointErrorMessage(joint, message);
  231. }
  232. }
  233. public virtual Vector3 GetJointAnchor(PhysicsJoint joint)
  234. { return Vector3.Zero; }
  235. public virtual Vector3 GetJointAxis(PhysicsJoint joint)
  236. { return Vector3.Zero; }
  237. public abstract void AddPhysicsActorTaint(PhysicsActor prim);
  238. public virtual void ProcessPreSimulation() { }
  239. /// <summary>
  240. /// Perform a simulation of the current physics scene over the given timestep.
  241. /// </summary>
  242. /// <param name="timeStep"></param>
  243. /// <returns>The number of frames simulated over that period.</returns>
  244. public abstract float Simulate(float timeStep);
  245. /// <summary>
  246. /// Get statistics about this scene.
  247. /// </summary>
  248. /// <remarks>This facility is currently experimental and subject to change.</remarks>
  249. /// <returns>
  250. /// A dictionary where the key is the statistic name. If no statistics are supplied then returns null.
  251. /// </returns>
  252. public virtual Dictionary<string, float> GetStats() { return null; }
  253. public abstract void SetTerrain(float[] heightMap);
  254. public abstract void SetWaterLevel(float baseheight);
  255. public abstract void DeleteTerrain();
  256. public abstract void Dispose();
  257. public abstract Dictionary<uint, float> GetTopColliders();
  258. /// <summary>
  259. /// True if the physics plugin supports raycasting against the physics scene
  260. /// </summary>
  261. public virtual bool SupportsRayCast()
  262. {
  263. return false;
  264. }
  265. /// <summary>
  266. /// Queue a raycast against the physics scene.
  267. /// The provided callback method will be called when the raycast is complete
  268. ///
  269. /// Many physics engines don't support collision testing at the same time as
  270. /// manipulating the physics scene, so we queue the request up and callback
  271. /// a custom method when the raycast is complete.
  272. /// This allows physics engines that give an immediate result to callback immediately
  273. /// and ones that don't, to callback when it gets a result back.
  274. ///
  275. /// ODE for example will not allow you to change the scene while collision testing or
  276. /// it asserts, 'opteration not valid for locked space'. This includes adding a ray to the scene.
  277. ///
  278. /// This is named RayCastWorld to not conflict with modrex's Raycast method.
  279. /// </summary>
  280. /// <param name="position">Origin of the ray</param>
  281. /// <param name="direction">Direction of the ray</param>
  282. /// <param name="length">Length of ray in meters</param>
  283. /// <param name="retMethod">Method to call when the raycast is complete</param>
  284. public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
  285. {
  286. if (retMethod != null)
  287. retMethod(false, Vector3.Zero, 0, 999999999999f, Vector3.Zero);
  288. }
  289. public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
  290. {
  291. if (retMethod != null)
  292. retMethod(new List<ContactResult>());
  293. }
  294. public virtual List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
  295. {
  296. return new List<ContactResult>();
  297. }
  298. public virtual object RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
  299. {
  300. return null;
  301. }
  302. public virtual bool SupportsRaycastWorldFiltered()
  303. {
  304. return false;
  305. }
  306. public virtual List<ContactResult> RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags flags)
  307. {
  308. return new List<ContactResult>();
  309. }
  310. public virtual List<ContactResult> BoxProbe(Vector3 position, Vector3 size, Quaternion orientation, int Count, RayFilterFlags flags)
  311. {
  312. return new List<ContactResult>();
  313. }
  314. public virtual List<ContactResult> SphereProbe(Vector3 position, float radius, int Count, RayFilterFlags flags)
  315. {
  316. return new List<ContactResult>();
  317. }
  318. public virtual List<ContactResult> PlaneProbe(PhysicsActor actor, Vector4 plane, int Count, RayFilterFlags flags)
  319. {
  320. return new List<ContactResult>();
  321. }
  322. public virtual int SitAvatar(PhysicsActor actor, Vector3 AbsolutePosition, Vector3 CameraPosition, Vector3 offset, Vector3 AvatarSize, SitAvatarCallback PhysicsSitResponse)
  323. {
  324. return 0;
  325. }
  326. // Extendable interface for new, physics engine specific operations
  327. public virtual object Extension(string pFunct, params object[] pParams)
  328. {
  329. // A NOP if the extension thing is not implemented by the physics engine
  330. return null;
  331. }
  332. public virtual void GetResults() { }
  333. public virtual bool IsThreaded { get {return false;} }
  334. }
  335. }