Merge branch 'master' into careminster-presence-refactor

OpenSim/Region/Application/ConfigurationLoader.cs

@@ -179,8 +179,10 @@ namespace OpenSim
             for (int i = 0 ; i < sources.Count ; i++)
             {
                 if (ReadConfig(sources[i]))
+                {
                     iniFileExists = true;
-                AddIncludes(sources);
+                    AddIncludes(sources);
+                }
             }
 
             if (!iniFileExists)
@@ -235,10 +237,19 @@ namespace OpenSim
                             string path = Path.Combine(basepath, chunkWithoutWildcards);
                             path = Path.GetFullPath(path) + chunkWithWildcards;
                             string[] paths = Util.Glob(path);
-                            foreach (string p in paths)
+                            
+                            // If the include path contains no wildcards, then warn the user that it wasn't found.
+                            if (wildcardIndex == -1 && paths.Length == 0)
                             {
-                                if (!sources.Contains(p))
-                                    sources.Add(p);
+                                m_log.WarnFormat("[CONFIG]: Could not find include file {0}", path);
+                            }
+                            else
+                            {                            
+                                foreach (string p in paths)
+                                {
+                                    if (!sources.Contains(p))
+                                        sources.Add(p);
+                                }
                             }
                         }
                     }

OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs

@@ -54,7 +54,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Assets
 //            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         
         private Scene m_scene;
-        private IAssetService m_assetService;
+//        private IAssetService m_assetService;
         private bool m_dumpAssetsToFile = false;
 
         #region IRegionModuleBase Members
@@ -85,7 +85,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Assets
         public void RegionLoaded(Scene scene)
         {
             
-            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+//            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
             m_scene.EventManager.OnRegisterCaps += RegisterCaps;
         }
 

OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml

@@ -14,6 +14,7 @@
         <RegionModule id="InventoryAccessModule" type="OpenSim.Region.CoreModules.Framework.InventoryAccess.BasicInventoryAccessModule" />
         <RegionModule id="HGInventoryAccessModule" type="OpenSim.Region.CoreModules.Framework.InventoryAccess.HGInventoryAccessModule" />
         <RegionModule id="LandManagementModule" type="OpenSim.Region.CoreModules.World.Land.LandManagementModule" />
+        <RegionModule id="PrimCountModule" type="OpenSim.Region.CoreModules.World.Land.PrimCountModule" />
         <RegionModule id="ExportSerialisationModule" type="OpenSim.Region.CoreModules.World.Serialiser.SerialiserModule" />
         <RegionModule id="ArchiverModule" type="OpenSim.Region.CoreModules.World.Archiver.ArchiverModule" />
         <RegionModule id="CapabilitiesModule" type="OpenSim.Region.CoreModules.Agent.Capabilities.CapabilitiesModule" />

OpenSim/Region/CoreModules/ServiceConnectorsOut/UserAccounts/UserAccountCache.cs

@@ -38,9 +38,10 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.UserAccounts
     {
         private const double CACHE_EXPIRATION_SECONDS = 120000.0; // 33 hours!
 
-        private static readonly ILog m_log =
-                LogManager.GetLogger(
-                MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log =
+//                LogManager.GetLogger(
+//                MethodBase.GetCurrentMethod().DeclaringType);
+        
         private ExpiringCache<UUID, UserAccount> m_UUIDCache;
         private ExpiringCache<string, UUID> m_NameCache;
 

OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs

@@ -569,37 +569,12 @@ namespace OpenSim.Region.CoreModules.World.Estate
 
                 try
                 {
+                    MemoryStream terrainStream = new MemoryStream(terrainData);
+                    terr.LoadFromStream(filename, terrainStream);
+                    terrainStream.Close();
 
-                    string localfilename = "terrain.raw";
-
-                    if (terrainData.Length == 851968)
-                    {
-                        localfilename = Path.Combine(Util.dataDir(),"terrain.raw"); // It's a .LLRAW
-                    }
-
-                    if (terrainData.Length == 196662) // 24-bit 256x256 Bitmap
-                        localfilename = Path.Combine(Util.dataDir(), "terrain.bmp");
-
-                    if (terrainData.Length == 256 * 256 * 4) // It's a .R32
-                        localfilename = Path.Combine(Util.dataDir(), "terrain.r32");
-
-                    if (terrainData.Length == 256 * 256 * 8) // It's a .R64
-                        localfilename = Path.Combine(Util.dataDir(), "terrain.r64");
-
-                    if (File.Exists(localfilename))
-                    {
-                        File.Delete(localfilename);
-                    }
-
-                    FileStream input = new FileStream(localfilename, FileMode.CreateNew);
-                    input.Write(terrainData, 0, terrainData.Length);
-                    input.Close();
-
-                    FileInfo x = new FileInfo(localfilename);
-
-                    terr.LoadFromFile(localfilename);
-                    remoteClient.SendAlertMessage("Your terrain was loaded as a ." + x.Extension + " file. It may take a few moments to appear.");
-
+                    FileInfo x = new FileInfo(filename);
+                    remoteClient.SendAlertMessage("Your terrain was loaded as a " + x.Extension + " file. It may take a few moments to appear.");
                 }
                 catch (IOException e)
                 {

OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs

@@ -0,0 +1,406 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Region.CoreModules.World.Land
+{
+    public class ParcelCounts
+    {
+        public int Owner = 0;
+        public int Group = 0;
+        public int Others = 0;
+        public Dictionary <UUID, int> Users =
+                new Dictionary <UUID, int>();
+    }
+
+    public class PrimCountModule : IPrimCountModule, INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+        private Dictionary<UUID, PrimCounts> m_PrimCounts =
+                new Dictionary<UUID, PrimCounts>();
+        private Dictionary<UUID, UUID> m_OwnerMap =
+                new Dictionary<UUID, UUID>();
+        private Dictionary<UUID, int> m_SimwideCounts =
+                new Dictionary<UUID, int>();
+        private Dictionary<UUID, ParcelCounts> m_ParcelCounts =
+                new Dictionary<UUID, ParcelCounts>();
+
+        // For now, a simple simwide taint to get this up. Later parcel based
+        // taint to allow recounting a parcel if only ownership has changed
+        // without recounting the whole sim.
+        private bool m_Tainted = true;
+        private Object m_TaintLock = new Object();
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_Scene = scene;
+
+            m_Scene.EventManager.OnParcelPrimCountAdd +=
+                    OnParcelPrimCountAdd;
+            m_Scene.EventManager.OnObjectBeingRemovedFromScene +=
+                    OnObjectBeingRemovedFromScene;
+            m_Scene.EventManager.OnParcelPrimCountTainted +=
+                    OnParcelPrimCountTainted;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {            
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "PrimCountModule"; }
+        }
+
+        private void OnParcelPrimCountAdd(SceneObjectGroup obj)
+        {
+            // If we're tainted already, don't bother to add. The next
+            // access will cause a recount anyway
+            lock (m_TaintLock)
+            {
+                if (!m_Tainted)
+                    AddObject(obj);
+            }
+        }
+
+        private void OnObjectBeingRemovedFromScene(SceneObjectGroup obj)
+        {
+            // Don't bother to update tainted counts
+            lock (m_TaintLock)
+            {
+                if (!m_Tainted)
+                    RemoveObject(obj);
+            }
+        }
+
+        private void OnParcelPrimCountTainted()
+        {
+            lock (m_TaintLock)
+                m_Tainted = true;
+        }
+
+        public void TaintPrimCount(ILandObject land)
+        {
+            lock (m_TaintLock)
+                m_Tainted = true;
+        }
+
+        public void TaintPrimCount(int x, int y)
+        {
+            lock (m_TaintLock)
+                m_Tainted = true;
+        }
+
+        public void TaintPrimCount()
+        {
+            lock (m_TaintLock)
+                m_Tainted = true;
+        }
+
+        // NOTE: Call under Taint Lock
+        private void AddObject(SceneObjectGroup obj)
+        {
+            if (obj.IsAttachment)
+                return;
+            if (((obj.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0))
+                return;
+
+            Vector3 pos = obj.AbsolutePosition;
+            ILandObject landObject = m_Scene.LandChannel.GetLandObject(pos.X, pos.Y);
+            LandData landData = landObject.LandData;
+
+            ParcelCounts parcelCounts;
+            if (m_ParcelCounts.TryGetValue(landData.GlobalID, out parcelCounts))
+            {
+                UUID landOwner = landData.OwnerID;
+                int partCount = obj.Parts.Length;
+
+                m_SimwideCounts[landOwner] += partCount;
+                if (parcelCounts.Users.ContainsKey(obj.OwnerID))
+                    parcelCounts.Users[obj.OwnerID] += partCount;
+                else
+                    parcelCounts.Users[obj.OwnerID] = partCount;
+
+                if (landData.IsGroupOwned)
+                {
+                    if (obj.OwnerID == landData.GroupID)
+                        parcelCounts.Owner += partCount;
+                    else if (obj.GroupID == landData.GroupID)
+                        parcelCounts.Group += partCount;
+                    else
+                        parcelCounts.Others += partCount;
+                }
+                else
+                {
+                    if (obj.OwnerID == landData.OwnerID)
+                        parcelCounts.Owner += partCount;
+                    else if (obj.GroupID == landData.GroupID)
+                        parcelCounts.Group += partCount;
+                    else
+                        parcelCounts.Others += partCount;
+                }
+            }
+        }
+
+        // NOTE: Call under Taint Lock
+        private void RemoveObject(SceneObjectGroup obj)
+        {
+        }
+
+        public IPrimCounts GetPrimCounts(UUID parcelID)
+        {
+            PrimCounts primCounts;
+
+            lock (m_PrimCounts)
+            {
+                if (m_PrimCounts.TryGetValue(parcelID, out primCounts))
+                    return primCounts;
+
+                primCounts = new PrimCounts(parcelID, this);
+                m_PrimCounts[parcelID] = primCounts;
+            }
+            return primCounts;
+        }
+
+        public int GetOwnerCount(UUID parcelID)
+        {
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                    return counts.Owner;
+            }
+            return 0;
+        }
+
+        public int GetGroupCount(UUID parcelID)
+        {
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                    return counts.Group;
+            }
+            return 0;
+        }
+
+        public int GetOthersCount(UUID parcelID)
+        {
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                    return counts.Others;
+            }
+            return 0;
+        }
+
+        public int GetSimulatorCount(UUID parcelID)
+        {
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+                
+                UUID owner;
+                if (m_OwnerMap.TryGetValue(parcelID, out owner))
+                {
+                    int val;
+                    if (m_SimwideCounts.TryGetValue(owner, out val))
+                        return val;
+                }
+            }
+            return 0;
+        }
+
+        public int GetUserCount(UUID parcelID, UUID userID)
+        {
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                {
+                    int val;
+                    if (counts.Users.TryGetValue(userID, out val))
+                        return val;
+                }
+            }
+            return 0;
+        }
+
+        // NOTE: This method MUST be called while holding the taint lock!
+        private void Recount()
+        {
+            m_OwnerMap.Clear();
+            m_SimwideCounts.Clear();
+            m_ParcelCounts.Clear();
+
+            List<ILandObject> land = m_Scene.LandChannel.AllParcels();
+
+            foreach (ILandObject l in land)
+            {
+                LandData landData = l.LandData;
+
+                m_OwnerMap[landData.GlobalID] = landData.OwnerID;
+                m_SimwideCounts[landData.OwnerID] = 0;
+                m_ParcelCounts[landData.GlobalID] = new ParcelCounts();
+            }
+
+            m_Scene.ForEachSOG(AddObject);
+
+            List<UUID> primcountKeys = new List<UUID>(m_PrimCounts.Keys);
+            foreach (UUID k in primcountKeys)
+            {
+                if (!m_OwnerMap.ContainsKey(k))
+                    m_PrimCounts.Remove(k);
+            }
+            m_Tainted = false;
+        }
+    }
+
+    public class PrimCounts : IPrimCounts
+    {
+        private PrimCountModule m_Parent;
+        private UUID m_ParcelID;
+        private UserPrimCounts m_UserPrimCounts;
+
+        public PrimCounts (UUID parcelID, PrimCountModule parent)
+        {
+            m_ParcelID = parcelID;
+            m_Parent = parent;
+
+            m_UserPrimCounts = new UserPrimCounts(this);
+        }
+
+        public int Owner
+        {
+            get
+            {
+                return m_Parent.GetOwnerCount(m_ParcelID);
+            }
+        }
+
+        public int Group
+        {
+            get
+            {
+                return m_Parent.GetGroupCount(m_ParcelID);
+            }
+        }
+
+        public int Others
+        {
+            get
+            {
+                return m_Parent.GetOthersCount(m_ParcelID);
+            }
+        }
+
+        public int Simulator
+        {
+            get
+            {
+                return m_Parent.GetSimulatorCount(m_ParcelID);
+            }
+        }
+
+        public IUserPrimCounts Users
+        {
+            get
+            {
+                return m_UserPrimCounts;
+            }
+        }
+
+        public int GetUserCount(UUID userID)
+        {
+            return m_Parent.GetUserCount(m_ParcelID, userID);
+        }
+    }
+
+    public class UserPrimCounts : IUserPrimCounts
+    {
+        private PrimCounts m_Parent;
+
+        public UserPrimCounts(PrimCounts parent)
+        {
+            m_Parent = parent;
+        }
+
+        public int this[UUID userID]
+        {
+            get
+            {
+                return m_Parent.GetUserCount(userID);
+            }
+        }
+    }
+}

OpenSim/Region/CoreModules/World/Region/RestartModule.cs

@@ -47,8 +47,8 @@ namespace OpenSim.Region.CoreModules.World.Region
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RestartModule")]
     public class RestartModule : INonSharedRegionModule, IRestartModule
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         protected Scene m_Scene;
         protected Timer m_CountdownTimer = null;

OpenSim/Region/CoreModules/World/Terrain/FileLoaders/Terragen.cs

@@ -30,6 +30,7 @@ using System.IO;
 using System.Text;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework;
 
 namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
 {
@@ -53,17 +54,120 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
             return retval;
         }
 
+        public ITerrainChannel LoadFile(string filename, int offsetX, int offsetY, int fileWidth, int fileHeight, int sectionWidth, int sectionHeight)
+        {
+            TerrainChannel retval = new TerrainChannel(sectionWidth, sectionHeight);
+
+            FileInfo file = new FileInfo(filename);
+            FileStream s = file.Open(FileMode.Open, FileAccess.Read);
+            BinaryReader bs = new BinaryReader(s);
+
+            bool eof = false;
+
+            int fileXPoints = 0;
+            int fileYPoints = 0;
+
+            // Terragen file
+            while (eof == false)
+            {
+                string tmp = Encoding.ASCII.GetString(bs.ReadBytes(4));
+                switch (tmp)
+                {
+                    case "SIZE":
+                        fileXPoints = bs.ReadInt16() + 1;
+                        fileYPoints = fileXPoints;
+                        bs.ReadInt16();
+                        break;
+                    case "XPTS":
+                        fileXPoints = bs.ReadInt16();
+                        bs.ReadInt16();
+                        break;
+                    case "YPTS":
+                        fileYPoints = bs.ReadInt16();
+                        bs.ReadInt16();
+                        break;
+                    case "ALTW":
+                        eof = true;
+                        Int16 heightScale = bs.ReadInt16();
+                        Int16 baseHeight = bs.ReadInt16();
+
+                        int currFileYOffset = 0;
+
+                        // if our region isn't on the first X section of the areas to be landscaped, then
+                        // advance to our section of the file
+                        while (currFileYOffset < offsetY)
+                        {
+                            // read a whole strip of regions
+                            int heightsToRead = sectionHeight * fileXPoints;
+                            bs.ReadBytes(heightsToRead * 2); // because the shorts are 2 bytes in the file
+                            currFileYOffset++;
+                        }
+
+                        for (int y = 0; y < sectionHeight; y++)
+                        {
+                            int currFileXOffset = 0;
+
+                            // if our region isn't the first X section of the areas to be landscaped, then
+                            // advance the stream to the X start pos of our section in the file
+                            // i.e. eat X upto where we start
+                            while (currFileXOffset < offsetX)
+                            {
+                                bs.ReadBytes(sectionWidth * 2); // 2 bytes = short
+                                currFileXOffset++;
+                            }
+
+                            // got to our X offset, so write our regions X line
+                            for (int x = 0; x < sectionWidth; x++)
+                            {
+                                // Read a strip and continue
+                                retval[x, y] = baseHeight + bs.ReadInt16() * (double)heightScale / 65536.0;
+                            }
+                            // record that we wrote it
+                            currFileXOffset++;
+
+                            // if our region isn't the last X section of the areas to be landscaped, then
+                            // advance the stream to the end of this Y column
+                            while (currFileXOffset < fileWidth)
+                            {
+                                // eat the next regions x line
+                                bs.ReadBytes(sectionWidth * 2); // 2 bytes = short
+                                currFileXOffset++;
+                            }
+                            //eat the last additional point
+                            bs.ReadInt16();
+                        }
+
+
+                        break;
+                    default:
+                        bs.ReadInt32();
+                        break;
+                }
+            }
+
+            bs.Close();
+            s.Close();
+
+            return retval;
+        }
+
         public ITerrainChannel LoadStream(Stream s)
         {
-            TerrainChannel retval = new TerrainChannel();
+
+            int w = (int)Constants.RegionSize;
+            int h = (int)Constants.RegionSize;
+
+            TerrainChannel retval = new TerrainChannel(w, h);
 
             BinaryReader bs = new BinaryReader(s);
 
             bool eof = false;
             if (Encoding.ASCII.GetString(bs.ReadBytes(16)) == "TERRAGENTERRAIN ")
             {
-                int w = 256;
-                int h = 256;
+
+                int fileWidth = w;
+                int fileHeight = h;
+
 
                 // Terragen file
                 while (eof == false)
@@ -73,30 +177,27 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
                     {
                         case "SIZE":
                             int sztmp = bs.ReadInt16() + 1;
-                            w = sztmp;
-                            h = sztmp;
+                            fileWidth = sztmp;
+                            fileHeight = sztmp;
                             bs.ReadInt16();
                             break;
                         case "XPTS":
-                            w = bs.ReadInt16();
+                            fileWidth = bs.ReadInt16();
                             bs.ReadInt16();
                             break;
                         case "YPTS":
-                            h = bs.ReadInt16();
+                            fileHeight = bs.ReadInt16();
                             bs.ReadInt16();
                             break;
                         case "ALTW":
                             eof = true;
                             Int16 heightScale = bs.ReadInt16();
                             Int16 baseHeight = bs.ReadInt16();
-                            retval = new TerrainChannel(w, h);
-                            int x;
-                            for (x = 0; x < w; x++)
+                            for (int y = 0; y < h; y++)
                             {
-                                int y;
-                                for (y = 0; y < h; y++)
+                                for (int x = 0; x < w; x++)
                                 {
-                                    retval[x, y] = baseHeight + bs.ReadInt16() * (double) heightScale / 65536.0;
+                                    retval[x, y] = baseHeight + bs.ReadInt16() * (double)heightScale / 65536.0;
                                 }
                             }
                             break;
@@ -114,12 +215,92 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
 
         public void SaveFile(string filename, ITerrainChannel map)
         {
-            throw new NotImplementedException();
+            FileInfo file = new FileInfo(filename);
+            FileStream s = file.Open(FileMode.Create, FileAccess.Write);
+            SaveStream(s, map);
+
+            s.Close();
         }
 
         public void SaveStream(Stream stream, ITerrainChannel map)
         {
-            throw new NotImplementedException();
+            BinaryWriter bs = new BinaryWriter(stream);
+
+            //find the max and min heights on the map
+            double heightMax = map[0,0];
+            double heightMin = map[0,0];
+
+            for (int y = 0; y < map.Height; y++)
+            {
+                for (int x = 0; x < map.Width; x++)
+                {
+                    double current = map[x,y];
+                    if (heightMax < current)
+                        heightMax = current;
+                    if (heightMin > current)
+                        heightMin = current;
+                }
+            }
+
+            double baseHeight = Math.Floor( (heightMax + heightMin) / 2d );
+
+            double horizontalScale = Math.Ceiling((heightMax - heightMin));
+
+            // if we are completely flat add 1cm range to avoid NaN divisions
+            if (horizontalScale < 0.01d)
+                horizontalScale = 0.01d;
+
+            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
+
+            bs.Write(enc.GetBytes("TERRAGENTERRAIN "));
+
+            bs.Write(enc.GetBytes("SIZE"));
+            bs.Write(Convert.ToInt16(Constants.RegionSize));
+            bs.Write(Convert.ToInt16(0));  // necessary padding
+
+            //The XPTS and YPTS chunks are not needed for square regions
+            //but L3DT won't load the terrain file properly without them.
+            bs.Write(enc.GetBytes("XPTS"));
+            bs.Write(Convert.ToInt16(Constants.RegionSize));
+            bs.Write(Convert.ToInt16(0));  // necessary padding
+
+            bs.Write(enc.GetBytes("YPTS"));
+            bs.Write(Convert.ToInt16(Constants.RegionSize));
+            bs.Write(Convert.ToInt16(0));  // necessary padding
+
+            bs.Write(enc.GetBytes("SCAL"));
+            bs.Write(ToLittleEndian(1f)); //we're going to say that 1 terrain unit is 1 metre
+            bs.Write(ToLittleEndian(1f));
+            bs.Write(ToLittleEndian(1f));
+
+            // as we are square and not projected on a sphere then the other
+            // header blocks are not required
+
+            // now write the elevation data
+            bs.Write(enc.GetBytes("ALTW"));
+            bs.Write(Convert.ToInt16(horizontalScale)); // range between max and min
+            bs.Write(Convert.ToInt16(baseHeight)); // base height or mid point
+
+            for (int y = 0; y < map.Height; y++)
+            {
+                for (int x = 0; x < map.Width; x++)
+                {
+                    float elevation = (float)((map[x,y] - baseHeight) * 65536 ) / (float)horizontalScale; // see LoadStream for inverse
+
+                    // clamp rounding issues
+                    if (elevation > Int16.MaxValue)
+                        elevation = Int16.MaxValue;
+                    else if (elevation < Int16.MinValue)
+                        elevation = Int16.MinValue;
+
+                    bs.Write(Convert.ToInt16(elevation));
+                }
+            }
+
+            //This is only necessary for older versions of Terragen.
+            bs.Write(enc.GetBytes("EOF "));
+
+            bs.Close();
         }
 
         public string FileExtension
@@ -127,16 +308,34 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
             get { return ".ter"; }
         }
 
-        public ITerrainChannel LoadFile(string filename, int x, int y, int fileWidth, int fileHeight, int w, int h)
-        {
-            throw new NotImplementedException();
-        }
-
         #endregion
 
         public override string ToString()
         {
             return "Terragen";
         }
+
+        /// <summary>
+        /// terragen SCAL floats need to be written intel ordered regardless of
+        /// big or little endian system
+        /// </summary>
+        /// <param name="number"></param>
+        /// <returns></returns>
+        private byte[] ToLittleEndian( float number)
+        {
+            byte[] retVal = BitConverter.GetBytes(number);
+            if (BitConverter.IsLittleEndian == false)
+            {
+                byte[] tmp = new byte[4];
+                for (int i = 0; i < 4; i++)
+                {
+                    tmp[i] = retVal[3 - i];
+                }
+                retVal = tmp;
+
+            }
+            return retVal ;
+        }
+
     }
 }

OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs

@@ -131,7 +131,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 m_scene.EventManager.OnNewClient += EventManager_OnNewClient;
                 m_scene.EventManager.OnPluginConsole += EventManager_OnPluginConsole;
                 m_scene.EventManager.OnTerrainTick += EventManager_OnTerrainTick;
-                InstallInterfaces();
             }
 
             InstallDefaultEffects();
@@ -140,6 +139,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
         public void RegionLoaded(Scene scene)
         {
+            //Do this here to give file loaders time to initialize and
+            //register their supported file extensions and file formats.
+            InstallInterfaces();
         }
 
         public void RemoveRegion(Scene scene)
@@ -1084,8 +1086,12 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         {
             // Load / Save
             string supportedFileExtensions = "";
+            string supportedFilesSeparator = "";
             foreach (KeyValuePair<string, ITerrainLoader> loader in m_loaders)
-                supportedFileExtensions += " " + loader.Key + " (" + loader.Value + ")";
+            {
+                supportedFileExtensions += supportedFilesSeparator + loader.Key + " (" + loader.Value + ")";
+                supportedFilesSeparator = ", ";
+            }
 
             Command loadFromFileCommand =
                 new Command("load", CommandIntentions.COMMAND_HAZARDOUS, InterfaceLoadFile, "Loads a terrain from a specified file.");

OpenSim/Region/Framework/Interfaces/IPrimCountModule.cs

@@ -0,0 +1,55 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public interface IPrimCountModule
+    {
+        void TaintPrimCount(ILandObject land);
+        void TaintPrimCount(int x, int y);
+        void TaintPrimCount();
+
+        IPrimCounts GetPrimCounts(UUID parcelID);
+    }
+
+    public interface IPrimCounts
+    {
+        int Owner { get; }
+        int Group { get; }
+        int Others { get; }
+        int Simulator { get; }
+        IUserPrimCounts Users { get; }
+    }
+
+    public interface IUserPrimCounts
+    {
+        int this[UUID agentID] { get; }
+    }
+}

OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs

@@ -711,7 +711,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         // and convert the regionName to the target region
                         if (regionName.Contains(".") && regionName.Contains(":"))
                         {
-                            List<GridRegion> regions = World.GridService.GetRegionsByName(World.RegionInfo.ScopeID, regionName, 1);
+//                            List<GridRegion> regions = World.GridService.GetRegionsByName(World.RegionInfo.ScopeID, regionName, 1);
                             string[] parts = regionName.Split(new char[] { ':' });
                             if (parts.Length > 2)
                                 regionName = parts[0] + ':' + parts[1] + "/ " + parts[2];

bin/OpenSimDefaults.ini

@@ -1186,6 +1186,11 @@
     ; This makes the Groups modules very chatty on the console.
     DebugEnabled     = false
 
+    ; Groups data is cached for this number of seconds before another request is made to the groups service
+    ; Set to 0 to disable the cache.
+    ; Default is 30 seconds
+    GroupsCacheTimeout = 30
+
     ; Specify which messaging module to use for groups messaging and if it's enabled
     ;MessagingModule = GroupsMessagingModule
     ;MessagingEnabled = true