1
0

SceneBase.cs 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637
  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. #pragma warning disable 414
  44. private static readonly string LogHeader = "[SCENE]";
  45. #pragma warning restore 414
  46. #region Events
  47. public event restart OnRestart;
  48. #endregion
  49. #region Fields
  50. public string Name { get { return RegionInfo.RegionName; } }
  51. public IConfigSource Config
  52. {
  53. get { return GetConfig(); }
  54. }
  55. protected virtual IConfigSource GetConfig()
  56. {
  57. return null;
  58. }
  59. /// <value>
  60. /// All the region modules attached to this scene.
  61. /// </value>
  62. public Dictionary<string, IRegionModuleBase> RegionModules
  63. {
  64. get { return m_regionModules; }
  65. }
  66. private Dictionary<string, IRegionModuleBase> m_regionModules = new Dictionary<string, IRegionModuleBase>();
  67. /// <value>
  68. /// The module interfaces available from this scene.
  69. /// </value>
  70. protected Dictionary<Type, List<object>> ModuleInterfaces = new Dictionary<Type, List<object>>();
  71. /// <summary>
  72. /// These two objects hold the information about any formats used
  73. /// by modules that hold agent specific data.
  74. /// </summary>
  75. protected List<UUID> FormatsOffered = new List<UUID>();
  76. protected Dictionary<object, List<UUID>> FormatsWanted = new Dictionary<object, List<UUID>>();
  77. protected Dictionary<string, object> ModuleAPIMethods = new Dictionary<string, object>();
  78. /// <value>
  79. /// The module commanders available from this scene
  80. /// </value>
  81. protected Dictionary<string, ICommander> m_moduleCommanders = new Dictionary<string, ICommander>();
  82. /// <value>
  83. /// Registered classes that are capable of creating entities.
  84. /// </value>
  85. protected Dictionary<PCode, IEntityCreator> m_entityCreators = new Dictionary<PCode, IEntityCreator>();
  86. /// <summary>
  87. /// The last allocated local prim id. When a new local id is requested, the next number in the sequence is
  88. /// dispensed.
  89. /// </summary>
  90. protected uint m_lastAllocatedLocalId = 720000;
  91. private readonly Mutex _primAllocateMutex = new Mutex(false);
  92. protected readonly ClientManager m_clientManager = new ClientManager();
  93. public bool LoginsEnabled
  94. {
  95. get
  96. {
  97. return m_loginsEnabled;
  98. }
  99. set
  100. {
  101. if (m_loginsEnabled != value)
  102. {
  103. m_loginsEnabled = value;
  104. EventManager.TriggerRegionLoginsStatusChange(this);
  105. }
  106. }
  107. }
  108. private bool m_loginsEnabled;
  109. public bool Ready
  110. {
  111. get
  112. {
  113. return m_ready;
  114. }
  115. set
  116. {
  117. if (m_ready != value)
  118. {
  119. m_ready = value;
  120. EventManager.TriggerRegionReadyStatusChange(this);
  121. }
  122. }
  123. }
  124. private bool m_ready;
  125. public float TimeDilation
  126. {
  127. get { return 1.0f; }
  128. }
  129. public ITerrainChannel Heightmap;
  130. public ITerrainChannel Bakedmap;
  131. /// <value>
  132. /// Allows retrieval of land information for this scene.
  133. /// </value>
  134. public ILandChannel LandChannel;
  135. /// <value>
  136. /// Manage events that occur in this scene (avatar movement, script rez, etc.). Commonly used by region modules
  137. /// to subscribe to scene events.
  138. /// </value>
  139. public EventManager EventManager
  140. {
  141. get { return m_eventManager; }
  142. }
  143. protected EventManager m_eventManager;
  144. protected ScenePermissions m_permissions;
  145. public ScenePermissions Permissions
  146. {
  147. get { return m_permissions; }
  148. }
  149. /* Used by the loadbalancer plugin on GForge */
  150. protected RegionStatus m_regStatus;
  151. public RegionStatus RegionStatus
  152. {
  153. get { return m_regStatus; }
  154. set { m_regStatus = value; }
  155. }
  156. #endregion
  157. public SceneBase(RegionInfo regInfo)
  158. {
  159. RegionInfo = regInfo;
  160. }
  161. #region Update Methods
  162. /// <summary>
  163. /// Called to update the scene loop by a number of frames and until shutdown.
  164. /// </summary>
  165. /// <param name="frames">
  166. /// Number of frames to update. Exits on shutdown even if there are frames remaining.
  167. /// If -1 then updates until shutdown.
  168. /// </param>
  169. /// <returns>true if update completed within minimum frame time, false otherwise.</returns>
  170. public abstract void Update(int frames);
  171. #endregion
  172. #region Terrain Methods
  173. /// <summary>
  174. /// Loads the World heightmap
  175. /// </summary>
  176. public abstract void LoadWorldMap();
  177. /// <summary>
  178. /// Send the region heightmap to the client
  179. /// </summary>
  180. /// <param name="RemoteClient">Client to send to</param>
  181. public virtual void SendLayerData(IClientAPI RemoteClient)
  182. {
  183. // RemoteClient.SendLayerData(Heightmap.GetFloatsSerialised());
  184. ITerrainModule terrModule = RequestModuleInterface<ITerrainModule>();
  185. if (terrModule != null)
  186. {
  187. terrModule.PushTerrain(RemoteClient);
  188. }
  189. }
  190. #endregion
  191. #region Add/Remove Agent/Avatar
  192. public abstract ISceneAgent AddNewAgent(IClientAPI client, PresenceType type);
  193. public abstract bool CloseAgent(UUID agentID, bool force);
  194. public bool TryGetScenePresence(UUID agentID, out object scenePresence)
  195. {
  196. scenePresence = null;
  197. ScenePresence sp = null;
  198. if (TryGetScenePresence(agentID, out sp))
  199. {
  200. scenePresence = sp;
  201. return true;
  202. }
  203. return false;
  204. }
  205. /// <summary>
  206. /// Try to get a scene presence from the scene
  207. /// </summary>
  208. /// <param name="agentID"></param>
  209. /// <param name="scenePresence">null if there is no scene presence with the given agent id</param>
  210. /// <returns>true if there was a scene presence with the given id, false otherwise.</returns>
  211. public abstract bool TryGetScenePresence(UUID agentID, out ScenePresence scenePresence);
  212. #endregion
  213. /// <summary>
  214. ///
  215. /// </summary>
  216. /// <returns></returns>
  217. public virtual RegionInfo RegionInfo { get; private set; }
  218. #region admin stuff
  219. public abstract void OtherRegionUp(GridRegion otherRegion);
  220. public virtual string GetSimulatorVersion()
  221. {
  222. return "OpenSimulator Server";
  223. }
  224. #endregion
  225. #region Shutdown
  226. /// <summary>
  227. /// Tidy before shutdown
  228. /// </summary>
  229. public virtual void Close()
  230. {
  231. try
  232. {
  233. EventManager.TriggerShutdown();
  234. }
  235. catch (Exception e)
  236. {
  237. m_log.Error(string.Format("[SCENE]: SceneBase.cs: Close() - Failed with exception {0}", e));
  238. }
  239. }
  240. #endregion
  241. /// <summary>
  242. /// Returns a new unallocated local ID
  243. /// </summary>
  244. /// <returns>A brand new local ID</returns>
  245. public uint AllocateLocalId()
  246. {
  247. uint myID;
  248. _primAllocateMutex.WaitOne();
  249. myID = ++m_lastAllocatedLocalId;
  250. _primAllocateMutex.ReleaseMutex();
  251. return myID;
  252. }
  253. #region Module Methods
  254. /// <summary>
  255. /// Add a region-module to this scene. TODO: This will replace AddModule in the future.
  256. /// </summary>
  257. /// <param name="name"></param>
  258. /// <param name="module"></param>
  259. public void AddRegionModule(string name, IRegionModuleBase module)
  260. {
  261. if (!RegionModules.ContainsKey(name))
  262. {
  263. RegionModules.Add(name, module);
  264. }
  265. }
  266. public void RemoveRegionModule(string name)
  267. {
  268. RegionModules.Remove(name);
  269. }
  270. /// <summary>
  271. /// Register a module commander.
  272. /// </summary>
  273. /// <param name="commander"></param>
  274. public void RegisterModuleCommander(ICommander commander)
  275. {
  276. lock (m_moduleCommanders)
  277. {
  278. m_moduleCommanders.Add(commander.Name, commander);
  279. }
  280. }
  281. /// <summary>
  282. /// Unregister a module commander and all its commands
  283. /// </summary>
  284. /// <param name="name"></param>
  285. public void UnregisterModuleCommander(string name)
  286. {
  287. lock (m_moduleCommanders)
  288. {
  289. ICommander commander;
  290. if (m_moduleCommanders.TryGetValue(name, out commander))
  291. m_moduleCommanders.Remove(name);
  292. }
  293. }
  294. /// <summary>
  295. /// Get a module commander
  296. /// </summary>
  297. /// <param name="name"></param>
  298. /// <returns>The module commander, null if no module commander with that name was found</returns>
  299. public ICommander GetCommander(string name)
  300. {
  301. lock (m_moduleCommanders)
  302. {
  303. if (m_moduleCommanders.ContainsKey(name))
  304. return m_moduleCommanders[name];
  305. }
  306. return null;
  307. }
  308. public Dictionary<string, ICommander> GetCommanders()
  309. {
  310. return m_moduleCommanders;
  311. }
  312. public List<UUID> GetFormatsOffered()
  313. {
  314. List<UUID> ret = new List<UUID>(FormatsOffered);
  315. return ret;
  316. }
  317. protected void CheckAndAddAgentDataFormats(object mod)
  318. {
  319. if (!(mod is IAgentStatefulModule))
  320. return;
  321. IAgentStatefulModule m = (IAgentStatefulModule)mod;
  322. List<UUID> renderFormats = m.GetRenderStateFormats();
  323. List<UUID> acceptFormats = m.GetAcceptStateFormats();
  324. foreach (UUID render in renderFormats)
  325. {
  326. if (!(FormatsOffered.Contains(render)))
  327. FormatsOffered.Add(render);
  328. }
  329. if (acceptFormats.Count == 0)
  330. return;
  331. if (FormatsWanted.ContainsKey(mod))
  332. return;
  333. FormatsWanted[mod] = acceptFormats;
  334. }
  335. /// <summary>
  336. /// Register an interface to a region module. This allows module methods to be called directly as
  337. /// well as via events. If there is already a module registered for this interface, it is not replaced
  338. /// (is this the best behaviour?)
  339. /// </summary>
  340. /// <param name="mod"></param>
  341. public void RegisterModuleInterface<M>(M mod)
  342. {
  343. // m_log.DebugFormat("[SCENE BASE]: Registering interface {0}", typeof(M));
  344. List<Object> l = null;
  345. if (!ModuleInterfaces.TryGetValue(typeof(M), out l))
  346. {
  347. l = new List<Object>();
  348. ModuleInterfaces.Add(typeof(M), l);
  349. }
  350. if (l.Count > 0)
  351. return;
  352. l.Add(mod);
  353. CheckAndAddAgentDataFormats(mod);
  354. if (mod is IEntityCreator)
  355. {
  356. IEntityCreator entityCreator = (IEntityCreator)mod;
  357. foreach (PCode pcode in entityCreator.CreationCapabilities)
  358. {
  359. m_entityCreators[pcode] = entityCreator;
  360. }
  361. }
  362. }
  363. public void UnregisterModuleInterface<M>(M mod)
  364. {
  365. // We can't unregister agent stateful modules because
  366. // that would require much more data to be held about formats
  367. // and would make that code slower and less efficient.
  368. // No known modules are unregistered anyway, ever, unless
  369. // the simulator shuts down anyway.
  370. if (mod is IAgentStatefulModule)
  371. return;
  372. List<Object> l;
  373. if (ModuleInterfaces.TryGetValue(typeof(M), out l))
  374. {
  375. if (l.Remove(mod))
  376. {
  377. if (mod is IEntityCreator)
  378. {
  379. IEntityCreator entityCreator = (IEntityCreator)mod;
  380. foreach (PCode pcode in entityCreator.CreationCapabilities)
  381. {
  382. m_entityCreators[pcode] = null;
  383. }
  384. }
  385. }
  386. }
  387. }
  388. public void StackModuleInterface<M>(M mod)
  389. {
  390. List<Object> l;
  391. if (ModuleInterfaces.ContainsKey(typeof(M)))
  392. l = ModuleInterfaces[typeof(M)];
  393. else
  394. l = new List<Object>();
  395. if (l.Contains(mod))
  396. return;
  397. l.Add(mod);
  398. CheckAndAddAgentDataFormats(mod);
  399. if (mod is IEntityCreator)
  400. {
  401. IEntityCreator entityCreator = (IEntityCreator)mod;
  402. foreach (PCode pcode in entityCreator.CreationCapabilities)
  403. {
  404. m_entityCreators[pcode] = entityCreator;
  405. }
  406. }
  407. ModuleInterfaces[typeof(M)] = l;
  408. }
  409. /// <summary>
  410. /// For the given interface, retrieve the region module which implements it.
  411. /// </summary>
  412. /// <returns>null if there is no registered module implementing that interface</returns>
  413. public T RequestModuleInterface<T>()
  414. {
  415. if (ModuleInterfaces.ContainsKey(typeof(T)) &&
  416. (ModuleInterfaces[typeof(T)].Count > 0))
  417. return (T)ModuleInterfaces[typeof(T)][0];
  418. else
  419. return default(T);
  420. }
  421. /// <summary>
  422. /// For the given interface, retrieve an array of region modules that implement it.
  423. /// </summary>
  424. /// <returns>an empty array if there are no registered modules implementing that interface</returns>
  425. public T[] RequestModuleInterfaces<T>()
  426. {
  427. if (ModuleInterfaces.ContainsKey(typeof(T)))
  428. {
  429. List<T> ret = new List<T>();
  430. foreach (Object o in ModuleInterfaces[typeof(T)])
  431. ret.Add((T)o);
  432. return ret.ToArray();
  433. }
  434. else
  435. {
  436. return new T[] {};
  437. }
  438. }
  439. #endregion
  440. /// <summary>
  441. /// Call this from a region module to add a command to the OpenSim console.
  442. /// </summary>
  443. /// <param name="mod"></param>
  444. /// <param name="command"></param>
  445. /// <param name="shorthelp"></param>
  446. /// <param name="longhelp"></param>
  447. /// <param name="callback"></param>
  448. public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
  449. {
  450. AddCommand(module, command, shorthelp, longhelp, string.Empty, callback);
  451. }
  452. /// <summary>
  453. /// Call this from a region module to add a command to the OpenSim console.
  454. /// </summary>
  455. /// <param name="mod">
  456. /// The use of IRegionModuleBase is a cheap trick to get a different method signature,
  457. /// though all new modules should be using interfaces descended from IRegionModuleBase anyway.
  458. /// </param>
  459. /// <param name="category">
  460. /// Category of the command. This is the section under which it will appear when the user asks for help
  461. /// </param>
  462. /// <param name="command"></param>
  463. /// <param name="shorthelp"></param>
  464. /// <param name="longhelp"></param>
  465. /// <param name="callback"></param>
  466. public void AddCommand(
  467. string category, IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
  468. {
  469. AddCommand(category, module, command, shorthelp, longhelp, string.Empty, callback);
  470. }
  471. /// <summary>
  472. /// Call this from a region module to add a command to the OpenSim console.
  473. /// </summary>
  474. /// <param name="mod"></param>
  475. /// <param name="command"></param>
  476. /// <param name="shorthelp"></param>
  477. /// <param name="longhelp"></param>
  478. /// <param name="descriptivehelp"></param>
  479. /// <param name="callback"></param>
  480. public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
  481. {
  482. string moduleName = "";
  483. if (module != null)
  484. moduleName = module.Name;
  485. AddCommand(moduleName, module, command, shorthelp, longhelp, descriptivehelp, callback);
  486. }
  487. /// <summary>
  488. /// Call this from a region module to add a command to the OpenSim console.
  489. /// </summary>
  490. /// <param name="category">
  491. /// Category of the command. This is the section under which it will appear when the user asks for help
  492. /// </param>
  493. /// <param name="mod"></param>
  494. /// <param name="command"></param>
  495. /// <param name="shorthelp"></param>
  496. /// <param name="longhelp"></param>
  497. /// <param name="descriptivehelp"></param>
  498. /// <param name="callback"></param>
  499. public void AddCommand(
  500. string category, IRegionModuleBase module, string command,
  501. string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
  502. {
  503. if (MainConsole.Instance == null)
  504. return;
  505. bool shared = false;
  506. if (module != null)
  507. shared = module is ISharedRegionModule;
  508. MainConsole.Instance.Commands.AddCommand(
  509. category, shared, command, shorthelp, longhelp, descriptivehelp, callback);
  510. }
  511. public virtual ISceneObject DeserializeObject(string representation)
  512. {
  513. return null;
  514. }
  515. public virtual bool AllowScriptCrossings
  516. {
  517. get { return false; }
  518. }
  519. public virtual void Start()
  520. {
  521. }
  522. public void Restart()
  523. {
  524. // This has to be here to fire the event
  525. restart handlerPhysicsCrash = OnRestart;
  526. if (handlerPhysicsCrash != null)
  527. handlerPhysicsCrash(RegionInfo);
  528. }
  529. public abstract bool CheckClient(UUID agentID, System.Net.IPEndPoint ep);
  530. }
  531. }