1 files changed, 636 insertions, 0 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
new file mode 100644
index 0000000..7ff3d40
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -0,0 +1,636 @@
+/*
+ * 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 System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+
+using OpenSim.Region.Framework.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Region.Framework.Scenes
+{
+    public abstract class SceneBase : IScene
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+#pragma warning disable 414
+        private static readonly string LogHeader = "[SCENE]";
+#pragma warning restore 414
+
+        #region Events
+
+        public event restart OnRestart;
+
+        #endregion
+
+        #region Fields
+
+        public string Name { get { return RegionInfo.RegionName; } }
+        
+        public IConfigSource Config
+        {
+            get { return GetConfig(); }
+        }
+
+        protected virtual IConfigSource GetConfig()
+        {
+            return null;
+        }
+
+        /// <value>
+        /// All the region modules attached to this scene.
+        /// </value>
+        public Dictionary<string, IRegionModuleBase> RegionModules
+        {
+            get { return m_regionModules; }
+        }
+        private Dictionary<string, IRegionModuleBase> m_regionModules = new Dictionary<string, IRegionModuleBase>();
+
+        /// <value>
+        /// The module interfaces available from this scene.
+        /// </value>
+        protected Dictionary<Type, List<object>> ModuleInterfaces = new Dictionary<Type, List<object>>();
+
+        /// <summary>
+        /// These two objects hold the information about any formats used
+        /// by modules that hold agent specific data.
+        /// </summary>
+        protected List<UUID> FormatsOffered = new List<UUID>();
+        protected Dictionary<object, List<UUID>> FormatsWanted = new Dictionary<object, List<UUID>>();
+
+        protected Dictionary<string, object> ModuleAPIMethods = new Dictionary<string, object>();
+
+        /// <value>
+        /// The module commanders available from this scene
+        /// </value>
+        protected Dictionary<string, ICommander> m_moduleCommanders = new Dictionary<string, ICommander>();
+        
+        /// <value>
+        /// Registered classes that are capable of creating entities.
+        /// </value>
+        protected Dictionary<PCode, IEntityCreator> m_entityCreators = new Dictionary<PCode, IEntityCreator>();
+
+        /// <summary>
+        /// The last allocated local prim id.  When a new local id is requested, the next number in the sequence is
+        /// dispensed.
+        /// </summary>
+        protected uint m_lastAllocatedLocalId = 720000;
+
+        private readonly Mutex _primAllocateMutex = new Mutex(false);
+        
+        protected readonly ClientManager m_clientManager = new ClientManager();
+
+        public bool LoginsEnabled
+        {
+            get
+            {
+                return m_loginsEnabled;
+            }
+
+            set
+            {
+                if (m_loginsEnabled != value)
+                {
+                    m_loginsEnabled = value;
+                    EventManager.TriggerRegionLoginsStatusChange(this);
+                }
+            }
+        }
+        private bool m_loginsEnabled;
+
+        public bool Ready
+        {
+            get
+            {
+                return m_ready;
+            }
+
+            set
+            {
+                if (m_ready != value)
+                {
+                    m_ready = value;
+                    EventManager.TriggerRegionReadyStatusChange(this);
+                }
+            }
+        }
+        private bool m_ready;
+
+        public float TimeDilation
+        {
+            get { return 1.0f; }
+        }
+
+        public ITerrainChannel Heightmap;
+
+        /// <value>
+        /// Allows retrieval of land information for this scene.
+        /// </value>
+        public ILandChannel LandChannel;
+
+        /// <value>
+        /// Manage events that occur in this scene (avatar movement, script rez, etc.).  Commonly used by region modules
+        /// to subscribe to scene events.
+        /// </value>
+        public EventManager EventManager
+        {
+            get { return m_eventManager; }
+        }
+        protected EventManager m_eventManager;
+
+        protected ScenePermissions m_permissions;
+        public ScenePermissions Permissions
+        {
+            get { return m_permissions; }
+        }
+
+         /* Used by the loadbalancer plugin on GForge */
+        protected RegionStatus m_regStatus;
+        public RegionStatus RegionStatus
+        {
+            get { return m_regStatus; }
+            set { m_regStatus = value; }
+        }
+
+        #endregion
+
+        public SceneBase(RegionInfo regInfo)
+        {
+            RegionInfo = regInfo;
+        }
+
+        #region Update Methods
+
+        /// <summary>
+        /// Called to update the scene loop by a number of frames and until shutdown.
+        /// </summary>
+        /// <param name="frames">
+        /// Number of frames to update.  Exits on shutdown even if there are frames remaining.
+        /// If -1 then updates until shutdown.
+        /// </param>
+        /// <returns>true if update completed within minimum frame time, false otherwise.</returns>
+        public abstract bool Update(int frames);
+
+        #endregion
+
+        #region Terrain Methods
+
+        /// <summary>
+        /// Loads the World heightmap
+        /// </summary>
+        public abstract void LoadWorldMap();
+
+        /// <summary>
+        /// Send the region heightmap to the client
+        /// </summary>
+        /// <param name="RemoteClient">Client to send to</param>
+        public virtual void SendLayerData(IClientAPI RemoteClient)
+        {
+            // RemoteClient.SendLayerData(Heightmap.GetFloatsSerialised());
+            ITerrainModule terrModule = RequestModuleInterface<ITerrainModule>();
+            if (terrModule != null)
+            {
+                terrModule.PushTerrain(RemoteClient);
+            }
+        }
+
+        #endregion
+
+        #region Add/Remove Agent/Avatar
+
+        public abstract ISceneAgent AddNewAgent(IClientAPI client, PresenceType type);
+
+        public abstract bool CloseAgent(UUID agentID, bool force);
+
+        public bool TryGetScenePresence(UUID agentID, out object scenePresence)
+        {
+            scenePresence = null;
+            ScenePresence sp = null;
+            if (TryGetScenePresence(agentID, out sp))
+            {
+                scenePresence = sp;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Try to get a scene presence from the scene
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="scenePresence">null if there is no scene presence with the given agent id</param>
+        /// <returns>true if there was a scene presence with the given id, false otherwise.</returns>
+        public abstract bool TryGetScenePresence(UUID agentID, out ScenePresence scenePresence);
+
+        #endregion
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual RegionInfo RegionInfo { get; private set; }
+
+        #region admin stuff
+        
+        public abstract void OtherRegionUp(GridRegion otherRegion);
+
+        public virtual string GetSimulatorVersion()
+        {
+            return "OpenSimulator Server";
+        }
+
+        #endregion
+
+        #region Shutdown
+
+        /// <summary>
+        /// Tidy before shutdown
+        /// </summary>
+        public virtual void Close()
+        {
+            try
+            {
+                EventManager.TriggerShutdown();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(string.Format("[SCENE]: SceneBase.cs: Close() - Failed with exception ", e));
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns a new unallocated local ID
+        /// </summary>
+        /// <returns>A brand new local ID</returns>
+        public uint AllocateLocalId()
+        {
+            uint myID;
+
+            _primAllocateMutex.WaitOne();
+            myID = ++m_lastAllocatedLocalId;
+            _primAllocateMutex.ReleaseMutex();
+
+            return myID;
+        }
+        
+        #region Module Methods
+
+        /// <summary>
+        /// Add a region-module to this scene. TODO: This will replace AddModule in the future.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="module"></param>
+        public void AddRegionModule(string name, IRegionModuleBase module)
+        {
+            if (!RegionModules.ContainsKey(name))
+            {
+                RegionModules.Add(name, module);
+            }
+        }
+
+        public void RemoveRegionModule(string name)
+        {
+            RegionModules.Remove(name);
+        }
+
+        /// <summary>
+        /// Register a module commander.
+        /// </summary>
+        /// <param name="commander"></param>
+        public void RegisterModuleCommander(ICommander commander)
+        {
+            lock (m_moduleCommanders)
+            {
+                m_moduleCommanders.Add(commander.Name, commander);
+            }
+        }
+
+        /// <summary>
+        /// Unregister a module commander and all its commands
+        /// </summary>
+        /// <param name="name"></param>
+        public void UnregisterModuleCommander(string name)
+        {
+            lock (m_moduleCommanders)
+            {
+                ICommander commander;
+                if (m_moduleCommanders.TryGetValue(name, out commander))
+                    m_moduleCommanders.Remove(name);
+            }
+        }
+
+        /// <summary>
+        /// Get a module commander
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns>The module commander, null if no module commander with that name was found</returns>
+        public ICommander GetCommander(string name)
+        {
+            lock (m_moduleCommanders)
+            {
+                if (m_moduleCommanders.ContainsKey(name))
+                    return m_moduleCommanders[name];
+            }
+            
+            return null;
+        }
+
+        public Dictionary<string, ICommander> GetCommanders()
+        {
+            return m_moduleCommanders;
+        }
+
+        public List<UUID> GetFormatsOffered()
+        {
+            List<UUID> ret = new List<UUID>(FormatsOffered);
+
+            return ret;
+        }
+
+        protected void CheckAndAddAgentDataFormats(object mod)
+        {
+            if (!(mod is IAgentStatefulModule))
+                return;
+
+            IAgentStatefulModule m = (IAgentStatefulModule)mod;
+
+            List<UUID> renderFormats = m.GetRenderStateFormats();
+            List<UUID> acceptFormats = m.GetAcceptStateFormats();
+
+            foreach (UUID render in renderFormats)
+            {
+                if (!(FormatsOffered.Contains(render)))
+                    FormatsOffered.Add(render);
+            }
+
+            if (acceptFormats.Count == 0)
+                return;
+
+            if (FormatsWanted.ContainsKey(mod))
+                return;
+
+            FormatsWanted[mod] = acceptFormats;
+        }
+
+        /// <summary>
+        /// Register an interface to a region module.  This allows module methods to be called directly as
+        /// well as via events.  If there is already a module registered for this interface, it is not replaced
+        /// (is this the best behaviour?)
+        /// </summary>
+        /// <param name="mod"></param>
+        public void RegisterModuleInterface<M>(M mod)
+        {
+//            m_log.DebugFormat("[SCENE BASE]: Registering interface {0}", typeof(M));
+            
+            List<Object> l = null;
+            if (!ModuleInterfaces.TryGetValue(typeof(M), out l))
+            {
+                l = new List<Object>();
+                ModuleInterfaces.Add(typeof(M), l);
+            }
+
+            if (l.Count > 0)
+                return;
+
+            l.Add(mod);
+
+            CheckAndAddAgentDataFormats(mod);
+
+            if (mod is IEntityCreator)
+            {
+                IEntityCreator entityCreator = (IEntityCreator)mod;
+                foreach (PCode pcode in entityCreator.CreationCapabilities)
+                {
+                    m_entityCreators[pcode] = entityCreator;
+                }
+            }
+        }
+
+        public void UnregisterModuleInterface<M>(M mod)
+        {
+            // We can't unregister agent stateful modules because
+            // that would require much more data to be held about formats
+            // and would make that code slower and less efficient.
+            // No known modules are unregistered anyway, ever, unless
+            // the simulator shuts down anyway.
+            if (mod is IAgentStatefulModule)
+                return;
+
+            List<Object> l;
+            if (ModuleInterfaces.TryGetValue(typeof(M), out l))
+            {
+                if (l.Remove(mod))
+                {
+                    if (mod is IEntityCreator)
+                    {
+                        IEntityCreator entityCreator = (IEntityCreator)mod;
+                        foreach (PCode pcode in entityCreator.CreationCapabilities)
+                        {
+                            m_entityCreators[pcode] = null;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void StackModuleInterface<M>(M mod)
+        {
+            List<Object> l;
+            if (ModuleInterfaces.ContainsKey(typeof(M)))
+                l = ModuleInterfaces[typeof(M)];
+            else
+                l = new List<Object>();
+
+            if (l.Contains(mod))
+                return;
+
+            l.Add(mod);
+
+            CheckAndAddAgentDataFormats(mod);
+
+            if (mod is IEntityCreator)
+            {
+                IEntityCreator entityCreator = (IEntityCreator)mod;
+                foreach (PCode pcode in entityCreator.CreationCapabilities)
+                {
+                    m_entityCreators[pcode] = entityCreator;
+                }
+            }
+
+            ModuleInterfaces[typeof(M)] = l;
+        }
+
+        /// <summary>
+        /// For the given interface, retrieve the region module which implements it.
+        /// </summary>
+        /// <returns>null if there is no registered module implementing that interface</returns>
+        public T RequestModuleInterface<T>()
+        {
+            if (ModuleInterfaces.ContainsKey(typeof(T)) &&
+                    (ModuleInterfaces[typeof(T)].Count > 0))
+                return (T)ModuleInterfaces[typeof(T)][0];
+            else
+                return default(T);
+        }
+
+        /// <summary>
+        /// For the given interface, retrieve an array of region modules that implement it.
+        /// </summary>
+        /// <returns>an empty array if there are no registered modules implementing that interface</returns>
+        public T[] RequestModuleInterfaces<T>()
+        {
+            if (ModuleInterfaces.ContainsKey(typeof(T)))
+            {
+                List<T> ret = new List<T>();
+
+                foreach (Object o in ModuleInterfaces[typeof(T)])
+                    ret.Add((T)o);
+                return ret.ToArray();
+            }
+            else
+            {
+                return new T[] {};
+            }
+        }
+        
+        #endregion
+        
+        /// <summary>
+        /// Call this from a region module to add a command to the OpenSim console.
+        /// </summary>
+        /// <param name="mod"></param>
+        /// <param name="command"></param>
+        /// <param name="shorthelp"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="callback"></param>
+        public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
+        {
+            AddCommand(module, command, shorthelp, longhelp, string.Empty, callback);
+        }
+
+        /// <summary>
+        /// Call this from a region module to add a command to the OpenSim console.
+        /// </summary>
+        /// <param name="mod">
+        /// The use of IRegionModuleBase is a cheap trick to get a different method signature,
+        /// though all new modules should be using interfaces descended from IRegionModuleBase anyway.
+        /// </param>
+        /// <param name="category">
+        /// Category of the command.  This is the section under which it will appear when the user asks for help
+        /// </param>
+        /// <param name="command"></param>
+        /// <param name="shorthelp"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="callback"></param>
+        public void AddCommand(
+            string category, IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
+        {
+            AddCommand(category, module, command, shorthelp, longhelp, string.Empty, callback);
+        }
+
+        /// <summary>
+        /// Call this from a region module to add a command to the OpenSim console.
+        /// </summary>
+        /// <param name="mod"></param>
+        /// <param name="command"></param>
+        /// <param name="shorthelp"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="descriptivehelp"></param>
+        /// <param name="callback"></param>
+        public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
+        {
+            string moduleName = "";
+
+            if (module != null)
+                moduleName = module.Name;
+
+            AddCommand(moduleName, module, command, shorthelp, longhelp, descriptivehelp, callback);
+        }
+
+        /// <summary>
+        /// Call this from a region module to add a command to the OpenSim console.
+        /// </summary>
+        /// <param name="category">
+        /// Category of the command.  This is the section under which it will appear when the user asks for help
+        /// </param>
+        /// <param name="mod"></param>
+        /// <param name="command"></param>
+        /// <param name="shorthelp"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="descriptivehelp"></param>
+        /// <param name="callback"></param>
+        public void AddCommand(
+            string category, IRegionModuleBase module, string command,
+            string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
+        {
+            if (MainConsole.Instance == null)
+                return;
+
+            bool shared = false;
+
+            if (module != null)
+                shared = module is ISharedRegionModule;
+
+            MainConsole.Instance.Commands.AddCommand(
+                category, shared, command, shorthelp, longhelp, descriptivehelp, callback);
+        }
+
+        public virtual ISceneObject DeserializeObject(string representation)
+        {
+            return null;
+        }
+
+        public virtual bool AllowScriptCrossings
+        {
+            get { return false; }
+        }
+
+        public virtual void Start()
+        {
+        }
+
+        public void Restart()
+        {
+            // This has to be here to fire the event
+            restart handlerPhysicsCrash = OnRestart;
+            if (handlerPhysicsCrash != null)
+                handlerPhysicsCrash(RegionInfo);
+        }
+
+        public abstract bool CheckClient(UUID agentID, System.Net.IPEndPoint ep);
+    }
+}