SceneBase.cs 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551
  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 System.Threading;
  31. using OpenMetaverse;
  32. using log4net;
  33. using Nini.Config;
  34. using OpenSim.Framework;
  35. using OpenSim.Framework.Console;
  36. using OpenSim.Region.Framework.Interfaces;
  37. using GridRegion = OpenSim.Services.Interfaces.GridRegion;
  38. namespace OpenSim.Region.Framework.Scenes
  39. {
  40. public abstract class SceneBase : IScene
  41. {
  42. private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  43. #region Events
  44. public event restart OnRestart;
  45. #endregion
  46. #region Fields
  47. public IConfigSource Config
  48. {
  49. get { return GetConfig(); }
  50. }
  51. protected virtual IConfigSource GetConfig()
  52. {
  53. return null;
  54. }
  55. /// <value>
  56. /// All the region modules attached to this scene.
  57. /// </value>
  58. public Dictionary<string, IRegionModule> Modules
  59. {
  60. get { return m_modules; }
  61. }
  62. protected Dictionary<string, IRegionModule> m_modules = new Dictionary<string, IRegionModule>();
  63. public Dictionary<string, IRegionModuleBase> RegionModules
  64. {
  65. get { return m_regionModules; }
  66. }
  67. private Dictionary<string, IRegionModuleBase> m_regionModules = new Dictionary<string, IRegionModuleBase>();
  68. /// <value>
  69. /// The module interfaces available from this scene.
  70. /// </value>
  71. protected Dictionary<Type, List<object>> ModuleInterfaces = new Dictionary<Type, List<object>>();
  72. protected Dictionary<string, object> ModuleAPIMethods = new Dictionary<string, object>();
  73. /// <value>
  74. /// The module commanders available from this scene
  75. /// </value>
  76. protected Dictionary<string, ICommander> m_moduleCommanders = new Dictionary<string, ICommander>();
  77. /// <value>
  78. /// Registered classes that are capable of creating entities.
  79. /// </value>
  80. protected Dictionary<PCode, IEntityCreator> m_entityCreators = new Dictionary<PCode, IEntityCreator>();
  81. /// <summary>
  82. /// The last allocated local prim id. When a new local id is requested, the next number in the sequence is
  83. /// dispensed.
  84. /// </summary>
  85. protected uint m_lastAllocatedLocalId = 720000;
  86. private readonly Mutex _primAllocateMutex = new Mutex(false);
  87. protected readonly ClientManager m_clientManager = new ClientManager();
  88. public float TimeDilation
  89. {
  90. get { return 1.0f; }
  91. }
  92. protected ulong m_regionHandle;
  93. protected string m_regionName;
  94. protected RegionInfo m_regInfo;
  95. public ITerrainChannel Heightmap;
  96. /// <value>
  97. /// Allows retrieval of land information for this scene.
  98. /// </value>
  99. public ILandChannel LandChannel;
  100. /// <value>
  101. /// Manage events that occur in this scene (avatar movement, script rez, etc.). Commonly used by region modules
  102. /// to subscribe to scene events.
  103. /// </value>
  104. public EventManager EventManager
  105. {
  106. get { return m_eventManager; }
  107. }
  108. protected EventManager m_eventManager;
  109. protected ScenePermissions m_permissions;
  110. public ScenePermissions Permissions
  111. {
  112. get { return m_permissions; }
  113. }
  114. /* Used by the loadbalancer plugin on GForge */
  115. protected RegionStatus m_regStatus;
  116. public RegionStatus RegionStatus
  117. {
  118. get { return m_regStatus; }
  119. set { m_regStatus = value; }
  120. }
  121. #endregion
  122. #region Update Methods
  123. /// <summary>
  124. /// Normally called once every frame/tick to let the world preform anything required (like running the physics simulation)
  125. /// </summary>
  126. public abstract void Update();
  127. #endregion
  128. #region Terrain Methods
  129. /// <summary>
  130. /// Loads the World heightmap
  131. /// </summary>
  132. public abstract void LoadWorldMap();
  133. /// <summary>
  134. /// Send the region heightmap to the client
  135. /// </summary>
  136. /// <param name="RemoteClient">Client to send to</param>
  137. public virtual void SendLayerData(IClientAPI RemoteClient)
  138. {
  139. RemoteClient.SendLayerData(Heightmap.GetFloatsSerialised());
  140. }
  141. #endregion
  142. #region Add/Remove Agent/Avatar
  143. public abstract void AddNewClient(IClientAPI client, PresenceType type);
  144. public abstract void RemoveClient(UUID agentID, bool closeChildAgents);
  145. public bool TryGetScenePresence(UUID agentID, out object scenePresence)
  146. {
  147. scenePresence = null;
  148. ScenePresence sp = null;
  149. if (TryGetScenePresence(agentID, out sp))
  150. {
  151. scenePresence = sp;
  152. return true;
  153. }
  154. return false;
  155. }
  156. public abstract bool TryGetScenePresence(UUID agentID, out ScenePresence scenePresence);
  157. #endregion
  158. /// <summary>
  159. ///
  160. /// </summary>
  161. /// <returns></returns>
  162. public virtual RegionInfo RegionInfo
  163. {
  164. get { return m_regInfo; }
  165. }
  166. #region admin stuff
  167. public virtual bool PresenceChildStatus(UUID avatarID)
  168. {
  169. return false;
  170. }
  171. public abstract void OtherRegionUp(GridRegion otherRegion);
  172. public virtual string GetSimulatorVersion()
  173. {
  174. return "OpenSimulator Server";
  175. }
  176. #endregion
  177. #region Shutdown
  178. /// <summary>
  179. /// Tidy before shutdown
  180. /// </summary>
  181. public virtual void Close()
  182. {
  183. // Shut down all non shared modules.
  184. foreach (IRegionModule module in Modules.Values)
  185. {
  186. if (!module.IsSharedModule)
  187. {
  188. module.Close();
  189. }
  190. }
  191. Modules.Clear();
  192. try
  193. {
  194. EventManager.TriggerShutdown();
  195. }
  196. catch (Exception e)
  197. {
  198. m_log.Error(string.Format("[SCENE]: SceneBase.cs: Close() - Failed with exception ", e));
  199. }
  200. }
  201. #endregion
  202. /// <summary>
  203. /// Returns a new unallocated local ID
  204. /// </summary>
  205. /// <returns>A brand new local ID</returns>
  206. public uint AllocateLocalId()
  207. {
  208. uint myID;
  209. _primAllocateMutex.WaitOne();
  210. myID = ++m_lastAllocatedLocalId;
  211. _primAllocateMutex.ReleaseMutex();
  212. return myID;
  213. }
  214. #region Module Methods
  215. /// <summary>
  216. /// Add a module to this scene.
  217. /// </summary>
  218. /// <param name="name"></param>
  219. /// <param name="module"></param>
  220. public void AddModule(string name, IRegionModule module)
  221. {
  222. if (!Modules.ContainsKey(name))
  223. {
  224. Modules.Add(name, module);
  225. }
  226. }
  227. /// <summary>
  228. /// Add a region-module to this scene. TODO: This will replace AddModule in the future.
  229. /// </summary>
  230. /// <param name="name"></param>
  231. /// <param name="module"></param>
  232. public void AddRegionModule(string name, IRegionModuleBase module)
  233. {
  234. if (!RegionModules.ContainsKey(name))
  235. {
  236. RegionModules.Add(name, module);
  237. }
  238. }
  239. public void RemoveRegionModule(string name)
  240. {
  241. RegionModules.Remove(name);
  242. }
  243. /// <summary>
  244. /// Register a module commander.
  245. /// </summary>
  246. /// <param name="commander"></param>
  247. public void RegisterModuleCommander(ICommander commander)
  248. {
  249. lock (m_moduleCommanders)
  250. {
  251. m_moduleCommanders.Add(commander.Name, commander);
  252. }
  253. }
  254. /// <summary>
  255. /// Unregister a module commander and all its commands
  256. /// </summary>
  257. /// <param name="name"></param>
  258. public void UnregisterModuleCommander(string name)
  259. {
  260. lock (m_moduleCommanders)
  261. {
  262. ICommander commander;
  263. if (m_moduleCommanders.TryGetValue(name, out commander))
  264. m_moduleCommanders.Remove(name);
  265. }
  266. }
  267. /// <summary>
  268. /// Get a module commander
  269. /// </summary>
  270. /// <param name="name"></param>
  271. /// <returns>The module commander, null if no module commander with that name was found</returns>
  272. public ICommander GetCommander(string name)
  273. {
  274. lock (m_moduleCommanders)
  275. {
  276. if (m_moduleCommanders.ContainsKey(name))
  277. return m_moduleCommanders[name];
  278. }
  279. return null;
  280. }
  281. public Dictionary<string, ICommander> GetCommanders()
  282. {
  283. return m_moduleCommanders;
  284. }
  285. /// <summary>
  286. /// Register an interface to a region module. This allows module methods to be called directly as
  287. /// well as via events. If there is already a module registered for this interface, it is not replaced
  288. /// (is this the best behaviour?)
  289. /// </summary>
  290. /// <param name="mod"></param>
  291. public void RegisterModuleInterface<M>(M mod)
  292. {
  293. // m_log.DebugFormat("[SCENE BASE]: Registering interface {0}", typeof(M));
  294. List<Object> l = null;
  295. if (!ModuleInterfaces.TryGetValue(typeof(M), out l))
  296. {
  297. l = new List<Object>();
  298. ModuleInterfaces.Add(typeof(M), l);
  299. }
  300. if (l.Count > 0)
  301. return;
  302. l.Add(mod);
  303. if (mod is IEntityCreator)
  304. {
  305. IEntityCreator entityCreator = (IEntityCreator)mod;
  306. foreach (PCode pcode in entityCreator.CreationCapabilities)
  307. {
  308. m_entityCreators[pcode] = entityCreator;
  309. }
  310. }
  311. }
  312. public void UnregisterModuleInterface<M>(M mod)
  313. {
  314. List<Object> l;
  315. if (ModuleInterfaces.TryGetValue(typeof(M), out l))
  316. {
  317. if (l.Remove(mod))
  318. {
  319. if (mod is IEntityCreator)
  320. {
  321. IEntityCreator entityCreator = (IEntityCreator)mod;
  322. foreach (PCode pcode in entityCreator.CreationCapabilities)
  323. {
  324. m_entityCreators[pcode] = null;
  325. }
  326. }
  327. }
  328. }
  329. }
  330. public void StackModuleInterface<M>(M mod)
  331. {
  332. List<Object> l;
  333. if (ModuleInterfaces.ContainsKey(typeof(M)))
  334. l = ModuleInterfaces[typeof(M)];
  335. else
  336. l = new List<Object>();
  337. if (l.Contains(mod))
  338. return;
  339. l.Add(mod);
  340. if (mod is IEntityCreator)
  341. {
  342. IEntityCreator entityCreator = (IEntityCreator)mod;
  343. foreach (PCode pcode in entityCreator.CreationCapabilities)
  344. {
  345. m_entityCreators[pcode] = entityCreator;
  346. }
  347. }
  348. ModuleInterfaces[typeof(M)] = l;
  349. }
  350. /// <summary>
  351. /// For the given interface, retrieve the region module which implements it.
  352. /// </summary>
  353. /// <returns>null if there is no registered module implementing that interface</returns>
  354. public T RequestModuleInterface<T>()
  355. {
  356. if (ModuleInterfaces.ContainsKey(typeof(T)) &&
  357. (ModuleInterfaces[typeof(T)].Count > 0))
  358. return (T)ModuleInterfaces[typeof(T)][0];
  359. else
  360. return default(T);
  361. }
  362. /// <summary>
  363. /// For the given interface, retrieve an array of region modules that implement it.
  364. /// </summary>
  365. /// <returns>an empty array if there are no registered modules implementing that interface</returns>
  366. public T[] RequestModuleInterfaces<T>()
  367. {
  368. if (ModuleInterfaces.ContainsKey(typeof(T)))
  369. {
  370. List<T> ret = new List<T>();
  371. foreach (Object o in ModuleInterfaces[typeof(T)])
  372. ret.Add((T)o);
  373. return ret.ToArray();
  374. }
  375. else
  376. {
  377. return new T[] { default(T) };
  378. }
  379. }
  380. #endregion
  381. /// <summary>
  382. /// Shows various details about the sim based on the parameters supplied by the console command in openSimMain.
  383. /// </summary>
  384. /// <param name="showParams">What to show</param>
  385. public virtual void Show(string[] showParams)
  386. {
  387. switch (showParams[0])
  388. {
  389. case "modules":
  390. m_log.Error("The currently loaded modules in " + RegionInfo.RegionName + " are:");
  391. foreach (IRegionModule module in Modules.Values)
  392. {
  393. if (!module.IsSharedModule)
  394. {
  395. m_log.Error("Region Module: " + module.Name);
  396. }
  397. }
  398. break;
  399. }
  400. }
  401. /// <summary>
  402. /// Call this from a region module to add a command to the OpenSim console.
  403. /// </summary>
  404. /// <param name="mod"></param>
  405. /// <param name="command"></param>
  406. /// <param name="shorthelp"></param>
  407. /// <param name="longhelp"></param>
  408. /// <param name="callback"></param>
  409. public void AddCommand(object mod, string command, string shorthelp, string longhelp, CommandDelegate callback)
  410. {
  411. AddCommand(mod, command, shorthelp, longhelp, string.Empty, callback);
  412. }
  413. /// <summary>
  414. /// Call this from a region module to add a command to the OpenSim console.
  415. /// </summary>
  416. /// <param name="mod"></param>
  417. /// <param name="command"></param>
  418. /// <param name="shorthelp"></param>
  419. /// <param name="longhelp"></param>
  420. /// <param name="descriptivehelp"></param>
  421. /// <param name="callback"></param>
  422. public void AddCommand(
  423. object mod, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
  424. {
  425. if (MainConsole.Instance == null)
  426. return;
  427. string modulename = String.Empty;
  428. bool shared = false;
  429. if (mod != null)
  430. {
  431. if (mod is IRegionModule)
  432. {
  433. IRegionModule module = (IRegionModule)mod;
  434. modulename = module.Name;
  435. shared = module.IsSharedModule;
  436. }
  437. else if (mod is IRegionModuleBase)
  438. {
  439. IRegionModuleBase module = (IRegionModuleBase)mod;
  440. modulename = module.Name;
  441. shared = mod is ISharedRegionModule;
  442. }
  443. else throw new Exception("AddCommand module parameter must be IRegionModule or IRegionModuleBase");
  444. }
  445. MainConsole.Instance.Commands.AddCommand(
  446. modulename, shared, command, shorthelp, longhelp, descriptivehelp, callback);
  447. }
  448. public virtual ISceneObject DeserializeObject(string representation)
  449. {
  450. return null;
  451. }
  452. public virtual bool AllowScriptCrossings
  453. {
  454. get { return false; }
  455. }
  456. public void Restart()
  457. {
  458. // This has to be here to fire the event
  459. restart handlerPhysicsCrash = OnRestart;
  460. if (handlerPhysicsCrash != null)
  461. handlerPhysicsCrash(RegionInfo);
  462. }
  463. public abstract bool CheckClient(UUID agentID, System.Net.IPEndPoint ep);
  464. }
  465. }