// This delegate was refactored for non-combined regions.
        // This combined region version will not use the pre-compiled lists of locations and ids
        private void SendCoarseLocationUpdates(UUID sceneId, ScenePresence presence, List <Vector3> coarseLocations, List <UUID> avatarUUIDs)
        {
            RegionConnections connectiondata = null;

            lock (m_regions)
            {
                if (m_regions.ContainsKey(sceneId))
                {
                    connectiondata = m_regions[sceneId];
                }
                else
                {
                    return;
                }
            }

            List <Vector3> CoarseLocations = new List <Vector3>();
            List <UUID>    AvatarUUIDs     = new List <UUID>();

            connectiondata.RegionScene.ForEachRootScenePresence(delegate(ScenePresence sp)
            {
                if (sp.UUID != presence.UUID)
                {
                    CoarseLocations.Add(sp.AbsolutePosition);
                    AvatarUUIDs.Add(sp.UUID);
                }
            });

            DistributeCoarseLocationUpdates(CoarseLocations, AvatarUUIDs, connectiondata, presence);
        }
//        /// <summary>
//        /// TODO:
//        /// </summary>
//        /// <param name="rdata"></param>
//        public void UnCombineRegion(RegionData rdata)
//        {
//            lock (m_regions)
//            {
//                if (m_regions.ContainsKey(rdata.RegionId))
//                {
//                    // uncombine root region and virtual regions
//                }
//                else
//                {
//                    foreach (RegionConnections r in m_regions.Values)
//                    {
//                        foreach (RegionData rd in r.ConnectedRegions)
//                        {
//                            if (rd.RegionId == rdata.RegionId)
//                            {
//                                // uncombine virtual region
//                            }
//                        }
//                    }
//                }
//            }
//        }

        public void ForwardPermissionRequests(RegionConnections BigRegion, Scene VirtualRegion)
        {
            if (BigRegion.PermissionModule == null)
            {
                BigRegion.PermissionModule = new RegionCombinerPermissionModule(BigRegion.RegionScene);
            }

            VirtualRegion.Permissions.OnBypassPermissions    += BigRegion.PermissionModule.BypassPermissions;
            VirtualRegion.Permissions.OnSetBypassPermissions += BigRegion.PermissionModule.SetBypassPermissions;
            VirtualRegion.Permissions.OnPropagatePermissions += BigRegion.PermissionModule.PropagatePermissions;
            VirtualRegion.Permissions.OnGenerateClientFlags  += BigRegion.PermissionModule.GenerateClientFlags;
            VirtualRegion.Permissions.OnAbandonParcel        += BigRegion.PermissionModule.CanAbandonParcel;
            VirtualRegion.Permissions.OnReclaimParcel        += BigRegion.PermissionModule.CanReclaimParcel;
            VirtualRegion.Permissions.OnDeedParcel           += BigRegion.PermissionModule.CanDeedParcel;
            VirtualRegion.Permissions.OnDeedObject           += BigRegion.PermissionModule.CanDeedObject;
            VirtualRegion.Permissions.OnIsGod                 += BigRegion.PermissionModule.IsGod;
            VirtualRegion.Permissions.OnDuplicateObject       += BigRegion.PermissionModule.CanDuplicateObject;
            VirtualRegion.Permissions.OnDeleteObject          += BigRegion.PermissionModule.CanDeleteObject;         //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnEditObject            += BigRegion.PermissionModule.CanEditObject;           //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnEditParcelProperties  += BigRegion.PermissionModule.CanEditParcelProperties; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnInstantMessage        += BigRegion.PermissionModule.CanInstantMessage;
            VirtualRegion.Permissions.OnInventoryTransfer     += BigRegion.PermissionModule.CanInventoryTransfer;    //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnIssueEstateCommand    += BigRegion.PermissionModule.CanIssueEstateCommand;   //FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnMoveObject            += BigRegion.PermissionModule.CanMoveObject;           //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnObjectEntry           += BigRegion.PermissionModule.CanObjectEntry;
            VirtualRegion.Permissions.OnReturnObjects         += BigRegion.PermissionModule.CanReturnObjects;        //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnRezObject             += BigRegion.PermissionModule.CanRezObject;            //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnRunConsoleCommand     += BigRegion.PermissionModule.CanRunConsoleCommand;
            VirtualRegion.Permissions.OnRunScript             += BigRegion.PermissionModule.CanRunScript;            //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCompileScript         += BigRegion.PermissionModule.CanCompileScript;
            VirtualRegion.Permissions.OnSellParcel            += BigRegion.PermissionModule.CanSellParcel;
            VirtualRegion.Permissions.OnTakeObject            += BigRegion.PermissionModule.CanTakeObject;
            VirtualRegion.Permissions.OnTakeCopyObject        += BigRegion.PermissionModule.CanTakeCopyObject;
            VirtualRegion.Permissions.OnTerraformLand         += BigRegion.PermissionModule.CanTerraformLand;
            VirtualRegion.Permissions.OnLinkObject            += BigRegion.PermissionModule.CanLinkObject;            //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDelinkObject          += BigRegion.PermissionModule.CanDelinkObject;          //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnBuyLand               += BigRegion.PermissionModule.CanBuyLand;               //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnViewNotecard          += BigRegion.PermissionModule.CanViewNotecard;          //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnViewScript            += BigRegion.PermissionModule.CanViewScript;            //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditNotecard          += BigRegion.PermissionModule.CanEditNotecard;          //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditScript            += BigRegion.PermissionModule.CanEditScript;            //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCreateObjectInventory += BigRegion.PermissionModule.CanCreateObjectInventory; //NOT IMPLEMENTED HERE
            VirtualRegion.Permissions.OnEditObjectInventory   += BigRegion.PermissionModule.CanEditObjectInventory;   //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnCopyObjectInventory   += BigRegion.PermissionModule.CanCopyObjectInventory;   //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDeleteObjectInventory += BigRegion.PermissionModule.CanDeleteObjectInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnResetScript           += BigRegion.PermissionModule.CanResetScript;
            VirtualRegion.Permissions.OnCreateUserInventory   += BigRegion.PermissionModule.CanCreateUserInventory;   //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCopyUserInventory     += BigRegion.PermissionModule.CanCopyUserInventory;     //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditUserInventory     += BigRegion.PermissionModule.CanEditUserInventory;     //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDeleteUserInventory   += BigRegion.PermissionModule.CanDeleteUserInventory;   //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnTeleport              += BigRegion.PermissionModule.CanTeleport;              //NOT YET IMPLEMENTED
        }
        public Vector2 GetSizeOfMegaregion(UUID regionId)
        {
            lock (m_regions)
            {
                if (m_regions.ContainsKey(regionId))
                {
                    RegionConnections rootConn = m_regions[regionId];

                    return(new Vector2((float)rootConn.XEnd, (float)rootConn.YEnd));
                }
            }

            throw new Exception(string.Format("Region with id {0} not found", regionId));
        }
        private bool DoWorkForOneRegionOverPlusXY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
        {
            // Offset (in meters) from the base of this region to the base of the root region.
            Vector3 offset = Vector3.Zero;

            offset.X = newConn.PosX - rootConn.PosX;
            offset.Y = newConn.PosY - rootConn.PosY;

            // The new total size of the region (in meters)
            // We just extend the X and Y dimensions so the extent might temporarily include areas without regions.
            Vector3 extents = Vector3.Zero;

            extents.X = Math.Max(rootConn.XEnd, offset.X + newConn.RegionScene.RegionInfo.RegionSizeX);
            extents.Y = Math.Max(rootConn.YEnd, offset.Y + newConn.RegionScene.RegionInfo.RegionSizeY);

            rootConn.UpdateExtents(extents);

            m_log.DebugFormat(
                "[REGION COMBINER MODULE]: Root region {0} is to the west of region {1}, Offset: {2}, Extents: {3}",
                rootConn.RegionScene.RegionInfo.RegionName,
                newConn.RegionScene.RegionInfo.RegionName, offset, extents);

            RegionData ConnectedRegion = new RegionData();

            ConnectedRegion.Offset      = offset;
            ConnectedRegion.RegionId    = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;
            rootConn.ConnectedRegions.Add(ConnectedRegion);

            // Inform root region Physics about the extents of this region
            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);

            // Inform Child region that it needs to forward it's terrain to the root region
            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);

            // Reset Terrain..  since terrain loads before we get here, we need to load
            // it again so it loads in the root region
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());

            // Create a client event forwarder and add this region's events to the root region.
            if (rootConn.ClientEventForwarder != null)
            {
                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
            }

            return(true);
        }
        /*
         * 20140215 radams1: The border stuff was removed and the addition of regions to the mega-regions
         *   was generalized. These functions are not needed for the generalized solution but left for reference.
         * private bool DoWorkForOneRegionOverXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
         * {
         *  Vector3 offset = Vector3.Zero;
         *  offset.X = newConn.PosX - rootConn.PosX;
         *  offset.Y = newConn.PosY - rootConn.PosY;
         *
         *  Vector3 extents = Vector3.Zero;
         *  extents.Y = newConn.YEnd + rootConn.YEnd;
         *  extents.X = rootConn.XEnd;
         *  rootConn.UpdateExtents(extents);
         *
         *  RegionData ConnectedRegion = new RegionData();
         *  ConnectedRegion.Offset = offset;
         *  ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
         *  ConnectedRegion.RegionScene = scene;
         *  rootConn.ConnectedRegions.Add(ConnectedRegion);
         *
         *  m_log.DebugFormat(
         *      "[REGION COMBINER MODULE]: Root region {0} is to the south of region {1}, Offset: {2}, Extents: {3}",
         *      rootConn.RegionScene.RegionInfo.RegionName,
         *      newConn.RegionScene.RegionInfo.RegionName, offset, extents);
         *
         *  rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
         *  scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);
         *
         *  // Reset Terrain..  since terrain normally loads first.
         *  //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
         *  scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
         *  //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
         *
         *  if (rootConn.ClientEventForwarder != null)
         *      rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
         *
         *  return true;
         * }
         *
         * private bool DoWorkForOneRegionOverPlusXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
         * {
         *  Vector3 offset = Vector3.Zero;
         *  offset.X = newConn.PosX - rootConn.PosX;
         *  offset.Y = newConn.PosY - rootConn.PosY;
         *
         *  Vector3 extents = Vector3.Zero;
         *
         *  // We do not want to inflate the extents for regions strictly to the NE of the root region, since this
         *  // would double count regions strictly to the north and east that have already been added.
         * //            extents.Y = regionConnections.YEnd + conn.YEnd;
         * //            extents.X = regionConnections.XEnd + conn.XEnd;
         * //            conn.UpdateExtents(extents);
         *
         *  extents.Y = rootConn.YEnd;
         *  extents.X = rootConn.XEnd;
         *
         *  RegionData ConnectedRegion = new RegionData();
         *  ConnectedRegion.Offset = offset;
         *  ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
         *  ConnectedRegion.RegionScene = scene;
         *
         *  rootConn.ConnectedRegions.Add(ConnectedRegion);
         *
         *  m_log.DebugFormat(
         *      "[REGION COMBINER MODULE]: Region {0} is to the southwest of Scene {1}, Offset: {2}, Extents: {3}",
         *      rootConn.RegionScene.RegionInfo.RegionName,
         *      newConn.RegionScene.RegionInfo.RegionName, offset, extents);
         *
         *  rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
         *  scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);
         *
         *  // Reset Terrain..  since terrain normally loads first.
         *  //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
         *  scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
         *  //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
         *
         *  if (rootConn.ClientEventForwarder != null)
         *      rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);
         *
         *  return true;
         *
         *  //scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset,extents);
         * }
         */

        private void DoWorkForRootRegion(RegionConnections rootConn, Scene scene)
        {
            m_log.DebugFormat("[REGION COMBINER MODULE]: Adding root region {0}", scene.RegionInfo.RegionName);

            RegionData rdata = new RegionData();

            rdata.Offset      = Vector3.Zero;
            rdata.RegionId    = scene.RegionInfo.originRegionID;
            rdata.RegionScene = scene;
            // save it's land channel
            rootConn.RegionLandChannel = scene.LandChannel;

            // Substitue our landchannel
            RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.LandChannel,
                                                                                    rootConn.ConnectedRegions);

            scene.LandChannel = lnd;

            // Forward the permissions modules of each of the connected regions to the root region
            lock (m_regions)
            {
                foreach (RegionData r in rootConn.ConnectedRegions)
                {
                    ForwardPermissionRequests(rootConn, r.RegionScene);
                }

                // Create the root region's Client Event Forwarder
                rootConn.ClientEventForwarder = new RegionCombinerClientEventForwarder(rootConn);

                // Sets up the CoarseLocationUpdate forwarder for this root region
                scene.EventManager.OnNewPresence += SetCoarseLocationDelegate;

                // Adds this root region to a dictionary of regions that are connectable
                m_regions.Add(scene.RegionInfo.originRegionID, rootConn);
            }
        }
        private void DoWorkForRootRegion(RegionConnections regionConnections, Scene scene)
        {
            RegionData rdata = new RegionData();
            rdata.Offset = Vector3.Zero;
            rdata.RegionId = scene.RegionInfo.RegionID;
            rdata.RegionScene = scene;
            // save it's land channel
            regionConnections.RegionLandChannel = scene.RequestModuleInterface<IParcelManagementModule>();

            // Substitue our landchannel
            RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.RequestModuleInterface<IParcelManagementModule>(),
                                                            regionConnections.ConnectedRegions);
            scene.RegisterModuleInterface<IParcelManagementModule>(lnd);
            // Forward the permissions modules of each of the connected regions to the root region
            lock (m_regions)
            {
                foreach (RegionData r in regionConnections.ConnectedRegions)
                {
                    ForwardPermissionRequests(regionConnections, r.RegionScene);
                }
            }
            // Create the root region's Client Event Forwarder
            regionConnections.ClientEventForwarder = new RegionCombinerClientEventForwarder(regionConnections);

            // Sets up the CoarseLocationUpdate forwarder for this root region
            scene.EventManager.OnNewPresence += SetCourseLocationDelegate;

            scene.EventManager.OnNewClient += EventManager_OnNewClient;
            scene.EventManager.OnClosingClient += OnClosingClient;

            // Adds this root region to a dictionary of regions that are connectable
            m_regions.Add(scene.RegionInfo.RegionID, regionConnections);
            ITerrainChannel terrainHeightmap = scene.RequestModuleInterface<ITerrainChannel>();
            landTerrainChannel.AddRegion(rdata, terrainHeightmap);
        }
        private bool DoWorkForOneRegionOverPlusXPlusY(RegionConnections conn, RegionConnections regionConnections, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = (((regionConnections.X)) -
                        ((conn.X)));
            offset.Y = (((regionConnections.Y)) -
                        ((conn.Y)));

            Vector3 extents = Vector3.Zero;
            extents.Y = regionConnections.YEnd + conn.YEnd;
            extents.X = regionConnections.XEnd + conn.XEnd;
            conn.UpdateExtents(extents);

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.RegionID;
            ConnectedRegion.RegionScene = scene;

            conn.ConnectedRegions.Add(ConnectedRegion);

            m_log.DebugFormat("Scene: {0} to the NorthEast of Scene{1} Offset: {2}. Extents:{3}",
                             conn.RegionScene.RegionInfo.RegionName,
                             regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

            conn.RegionScene.SceneGraph.PhysicsScene.Combine(null, Vector3.Zero, extents);
            scene.SceneGraph.PhysicsScene.Combine(conn.RegionScene.SceneGraph.PhysicsScene, offset, Vector3.Zero);
            
            // Reset Terrain..  since terrain normally loads first.
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            ITerrainChannel terrainHeightmap = scene.RequestModuleInterface<ITerrainChannel>();
            scene.SceneGraph.PhysicsScene.SetTerrain(terrainHeightmap.GetFloatsSerialised(scene), terrainHeightmap.GetDoubles(scene));
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            
            if (conn.ClientEventForwarder != null)
                conn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            landTerrainChannel.AddRegion(ConnectedRegion, terrainHeightmap);

            return true;

            //scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset,extents);

        }
        private bool DoWorkForOneRegionOverPlusXY(RegionConnections conn, RegionConnections regionConnections, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = (((regionConnections.X)) -
                        ((conn.X)));
            offset.Y = (((regionConnections.Y)) -
                        ((conn.Y)));

            Vector3 extents = Vector3.Zero;
            extents.Y = conn.YEnd;
            extents.X = conn.XEnd + regionConnections.XEnd;

            conn.UpdateExtents(extents);

            m_log.DebugFormat("Scene: {0} to the west of Scene{1} Offset: {2}. Extents:{3}",
                              conn.RegionScene.RegionInfo.RegionName,
                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.RegionID;
            ConnectedRegion.RegionScene = scene;
            conn.ConnectedRegions.Add(ConnectedRegion);

            // Inform root region Physics about the extents of this region
            conn.RegionScene.SceneGraph.PhysicsScene.Combine(null, Vector3.Zero, extents);

            // Inform Child region that it needs to forward it's terrain to the root region
            scene.SceneGraph.PhysicsScene.Combine(conn.RegionScene.SceneGraph.PhysicsScene, offset, Vector3.Zero);

            // Reset Terrain..  since terrain loads before we get here, we need to load 
            // it again so it loads in the root region
            ITerrainChannel terrainHeightmap = scene.RequestModuleInterface<ITerrainChannel>();
            scene.SceneGraph.PhysicsScene.SetTerrain(terrainHeightmap.GetFloatsSerialised(scene), terrainHeightmap.GetDoubles(scene));

            // Create a client event forwarder and add this region's events to the root region.
            if (conn.ClientEventForwarder != null)
                conn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            landTerrainChannel.AddRegion(ConnectedRegion, terrainHeightmap);
            return true;
        }
        private void RegionLoadedDoWork(Scene scene)
        {
/* 
            // For testing on a single instance
            if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
                return;
            // 
*/
            if(landTerrainChannel == null)
                landTerrainChannel = new RegionCombinerLargeTerrainChannel();
            
            lock (m_startingScenes)
                m_startingScenes.Add(scene.RegionInfo.RegionID, scene);

            RegionConnections regionConnections = new RegionConnections();
            regionConnections.ConnectedRegions = new List<RegionData>();
            regionConnections.RegionScene = scene;
            regionConnections.RegionLandChannel = scene.RequestModuleInterface<IParcelManagementModule>();
            regionConnections.RegionId = scene.RegionInfo.RegionID;
            regionConnections.X = scene.RegionInfo.RegionLocX;
            regionConnections.Y = scene.RegionInfo.RegionLocY;
            regionConnections.XEnd = (int)Constants.RegionSize;
            regionConnections.YEnd = (int)Constants.RegionSize;


            lock (m_regions)
            {
                bool connectedYN = false;

                foreach (RegionConnections conn in m_regions.Values)
                {
                    #region commented
                    /*
                    // If we're one region over +x +y
                    //xxy
                    //xxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd 
                        == (regionConnections.X * (int)Constants.RegionSize)) 
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd 
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int) Constants.RegionSize)) -
                                    ((conn.X * (int) Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int) Constants.RegionSize)) -
                                    ((conn.Y * (int) Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northwest of Scene{1}.  Offset: {2}.  Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName,
                                          offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                            
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    //If we're one region over x +y
                    //xxx
                    //xxx
                    //xyx
                    if ((((int)conn.X * (int)Constants.RegionSize)
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the north of Scene{1}.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x +y
                    //xxx
                    //xxx
                    //yxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northeast of Scene.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);


                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x y
                    //xxx
                    //yxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize)
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the east of Scene{1} Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                        // If we're one region over -x -y
                        //yxx
                        //xxx
                        //xxx
                        if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                            == (regionConnections.X * (int)Constants.RegionSize))
                            && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                            == (regionConnections.Y * (int)Constants.RegionSize)))
                        {
                            Vector3 offset = Vector3.Zero;
                            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                        ((conn.X * (int)Constants.RegionSize)));
                            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                        ((conn.Y * (int)Constants.RegionSize)));

                            Vector3 extents = Vector3.Zero;
                            extents.Y = regionConnections.YEnd + conn.YEnd;
                            extents.X = conn.XEnd + conn.XEnd;

                            m_log.DebugFormat("Scene: {0} to the northeast of Scene{1} Offset: {2}. Extents:{3}",
                                              conn.RegionScene.RegionInfo.RegionName,
                                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                            connectedYN = true;
                            break;
                        }
                        */
                    #endregion

                    // If we're one region over +x y
                    //xxx
                    //xxy
                    //xxx


                    if ((int)conn.X + conn.XEnd
                        >= (regionConnections.X)
                        && ((int)conn.Y)
                        >= (regionConnections.Y))
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(conn, regionConnections, scene);
                        break;
                    }

                    // If we're one region over x +y
                    //xyx
                    //xxx
                    //xxx
                    if ((((int)conn.X)
                        >= (regionConnections.X))
                        && (((int)conn.Y) + conn.YEnd
                        >= (regionConnections.Y)))
                    {
                        connectedYN = DoWorkForOneRegionOverXPlusY(conn, regionConnections, scene);
                        break;
                    }

                    // If we're one region over +x +y
                    //xxy
                    //xxx
                    //xxx
                    if ((((int)conn.X) + conn.YEnd
                        >= (regionConnections.X))
                        && (((int)conn.Y) + conn.YEnd
                        >= (regionConnections.Y)))
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXPlusY(conn, regionConnections, scene);
                        break;

                    }
                }

                // If !connectYN means that this region is a root region
                if (!connectedYN)
                {
                    DoWorkForRootRegion(regionConnections, scene);
                }
            }
            // Set up infinite borders around the entire AABB of the combined ConnectedRegions
            AdjustLargeRegionBounds();
        }
        private bool DoWorkForOneRegionOverPlusXY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
        {
            // Offset (in meters) from the base of this region to the base of the root region.
            Vector3 offset = Vector3.Zero;
            offset.X = newConn.PosX - rootConn.PosX;
            offset.Y = newConn.PosY - rootConn.PosY;

            // The new total size of the region (in meters)
            // We just extend the X and Y dimensions so the extent might temporarily include areas without regions.
            Vector3 extents = Vector3.Zero;
            extents.X = Math.Max(rootConn.XEnd, offset.X + newConn.RegionScene.RegionInfo.RegionSizeX);
            extents.Y = Math.Max(rootConn.YEnd, offset.Y + newConn.RegionScene.RegionInfo.RegionSizeY);

            rootConn.UpdateExtents(extents);

            m_log.DebugFormat(
                "[REGION COMBINER MODULE]: Root region {0} is to the west of region {1}, Offset: {2}, Extents: {3}",
                rootConn.RegionScene.RegionInfo.RegionName,
                newConn.RegionScene.RegionInfo.RegionName, offset, extents);

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;
            rootConn.ConnectedRegions.Add(ConnectedRegion);

            // Inform root region Physics about the extents of this region
            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);

            // Inform Child region that it needs to forward it's terrain to the root region
            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);

            // Reset Terrain..  since terrain loads before we get here, we need to load 
            // it again so it loads in the root region
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());

            // Create a client event forwarder and add this region's events to the root region.
            if (rootConn.ClientEventForwarder != null)
                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            return true;
        }
 public RegionCombinerClientEventForwarder(RegionConnections rootScene)
 {
     m_rootScene = rootScene.RegionScene;
 }
示例#12
0
        private void DistributeCourseLocationUpdates(List<Vector3> locations, List<UUID> uuids, 
                                                     RegionConnections connectiondata, ScenePresence rootPresence)
        {
            RegionData[] rdata = connectiondata.ConnectedRegions.ToArray();
            //List<IClientAPI> clients = new List<IClientAPI>();
            Dictionary<Vector2, RegionCourseLocationStruct> updates = new Dictionary<Vector2, RegionCourseLocationStruct>();
            
            // Root Region entry
            RegionCourseLocationStruct rootupdatedata = new RegionCourseLocationStruct();
            rootupdatedata.Locations = new List<Vector3>();
            rootupdatedata.Uuids = new List<UUID>();
            rootupdatedata.Offset = Vector2.Zero;

            rootupdatedata.UserAPI = rootPresence.ControllingClient;

            if (rootupdatedata.UserAPI != null)
                updates.Add(Vector2.Zero, rootupdatedata);

            //Each Region needs an entry or we will end up with dead minimap dots
            foreach (RegionData regiondata in rdata)
            {
                Vector2 offset = new Vector2(regiondata.Offset.X, regiondata.Offset.Y);
                RegionCourseLocationStruct updatedata = new RegionCourseLocationStruct();
                updatedata.Locations = new List<Vector3>();
                updatedata.Uuids = new List<UUID>();
                updatedata.Offset = offset;

                if (offset == Vector2.Zero)
                    updatedata.UserAPI = rootPresence.ControllingClient;
                else
                    updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);

                if (updatedata.UserAPI != null)
                    updates.Add(offset, updatedata);
            }

            // go over the locations and assign them to an IClientAPI
            for (int i = 0; i < locations.Count; i++)
            //{locations[i]/(int) Constants.RegionSize;
            {
                Vector3 pPosition = new Vector3((int)locations[i].X / (int)Constants.RegionSize, 
                                                (int)locations[i].Y / (int)Constants.RegionSize, locations[i].Z);
                Vector2 offset = new Vector2(pPosition.X*(int) Constants.RegionSize,
                                             pPosition.Y*(int) Constants.RegionSize);
                
                if (!updates.ContainsKey(offset))
                {
                    // This shouldn't happen
                    RegionCourseLocationStruct updatedata = new RegionCourseLocationStruct();
                    updatedata.Locations = new List<Vector3>();
                    updatedata.Uuids = new List<UUID>();
                    updatedata.Offset = offset;
                    
                    if (offset == Vector2.Zero)
                        updatedata.UserAPI = rootPresence.ControllingClient;
                    else 
                        updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);

                    updates.Add(offset,updatedata);
                }
                
                updates[offset].Locations.Add(locations[i]);
                updates[offset].Uuids.Add(uuids[i]);
            }

            // Send out the CoarseLocationupdates from their respective client connection based on where the avatar is
            foreach (Vector2 offset in updates.Keys)
            {
                if (updates[offset].UserAPI != null)
                {
                    updates[offset].UserAPI.SendCoarseLocationUpdate(updates[offset].Uuids,updates[offset].Locations);
                }
            }
        }
示例#13
0
        private bool DoWorkForOneRegionOverPlusXPlusY(RegionConnections conn, RegionConnections regionConnections, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                        ((conn.X * (int)Constants.RegionSize)));
            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                        ((conn.Y * (int)Constants.RegionSize)));

            Vector3 extents = Vector3.Zero;
            extents.Y = regionConnections.YEnd + conn.YEnd;
            extents.X = regionConnections.XEnd + conn.XEnd;
            conn.UpdateExtents(extents);

            scene.BordersLocked = true;
            conn.RegionScene.BordersLocked = true;

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;

            conn.ConnectedRegions.Add(ConnectedRegion);

            m_log.DebugFormat("Scene: {0} to the NorthEast of Scene{1} Offset: {2}. Extents:{3}",
                             conn.RegionScene.RegionInfo.RegionName,
                             regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

            conn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, Vector3.Zero);
            lock (conn.RegionScene.NorthBorders)
            {
                if (conn.RegionScene.NorthBorders.Count == 1)// &&  2)
                {
                    //compound border
                    // already locked above
                    conn.RegionScene.NorthBorders[0].BorderLine.Z += (int)Constants.RegionSize;

                    lock (conn.RegionScene.EastBorders)
                        conn.RegionScene.EastBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                    lock (conn.RegionScene.WestBorders)
                        conn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                }
            }

            lock (scene.SouthBorders)
            {
                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocY - conn.RegionScene.RegionInfo.RegionLocY) * (int)Constants.RegionSize); //auto teleport south
                scene.SouthBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
                scene.SouthBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
            }

            lock (conn.RegionScene.EastBorders)
            {
                if (conn.RegionScene.EastBorders.Count == 1)// && conn.RegionScene.EastBorders.Count == 2)
                {

                    conn.RegionScene.EastBorders[0].BorderLine.Z += (int)Constants.RegionSize;
                    lock (conn.RegionScene.NorthBorders)
                        conn.RegionScene.NorthBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                    lock (conn.RegionScene.SouthBorders)
                        conn.RegionScene.SouthBorders[0].BorderLine.Y += (int)Constants.RegionSize;


                }
            }

            lock (scene.WestBorders)
            {
                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocX - conn.RegionScene.RegionInfo.RegionLocX) * (int)Constants.RegionSize); //auto teleport West
                scene.WestBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
                scene.WestBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
            }

            /*
                                    else
                                    {
                                        conn.RegionScene.NorthBorders[0].BorderLine.Z += (int)Constants.RegionSize;
                                        conn.RegionScene.EastBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                                        conn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                                        scene.SouthBorders[0].BorderLine.Z += (int)Constants.RegionSize; //auto teleport south
                                    }
            */


            // Reset Terrain..  since terrain normally loads first.
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            scene.BordersLocked = false;
            conn.RegionScene.BordersLocked = false;

            if (conn.ClientEventForwarder != null)
                conn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            return true;

            //scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset,extents);

        }
示例#14
0
        private void RegionLoadedDoWork(Scene scene)
        {
/* 
            // For testing on a single instance
            if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
                return;
            // 
*/
            lock (m_startingScenes)
                m_startingScenes.Add(scene.RegionInfo.originRegionID, scene);

            // Give each region a standard set of non-infinite borders
            Border northBorder = new Border();
            northBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, (int)Constants.RegionSize);  //<---
            northBorder.CrossDirection = Cardinals.N;
            scene.NorthBorders[0] = northBorder;

            Border southBorder = new Border();
            southBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, 0);    //--->
            southBorder.CrossDirection = Cardinals.S;
            scene.SouthBorders[0] = southBorder;

            Border eastBorder = new Border();
            eastBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, (int)Constants.RegionSize);   //<---
            eastBorder.CrossDirection = Cardinals.E;
            scene.EastBorders[0] = eastBorder;

            Border westBorder = new Border();
            westBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, 0);     //--->
            westBorder.CrossDirection = Cardinals.W;
            scene.WestBorders[0] = westBorder;



            RegionConnections regionConnections = new RegionConnections();
            regionConnections.ConnectedRegions = new List<RegionData>();
            regionConnections.RegionScene = scene;
            regionConnections.RegionLandChannel = scene.LandChannel;
            regionConnections.RegionId = scene.RegionInfo.originRegionID;
            regionConnections.X = scene.RegionInfo.RegionLocX;
            regionConnections.Y = scene.RegionInfo.RegionLocY;
            regionConnections.XEnd = (int)Constants.RegionSize;
            regionConnections.YEnd = (int)Constants.RegionSize;


            lock (m_regions)
            {
                bool connectedYN = false;

                foreach (RegionConnections conn in m_regions.Values)
                {
                    #region commented
                    /*
                    // If we're one region over +x +y
                    //xxy
                    //xxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd 
                        == (regionConnections.X * (int)Constants.RegionSize)) 
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd 
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int) Constants.RegionSize)) -
                                    ((conn.X * (int) Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int) Constants.RegionSize)) -
                                    ((conn.Y * (int) Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northwest of Scene{1}.  Offset: {2}.  Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName,
                                          offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                            
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    //If we're one region over x +y
                    //xxx
                    //xxx
                    //xyx
                    if ((((int)conn.X * (int)Constants.RegionSize)
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the north of Scene{1}.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x +y
                    //xxx
                    //xxx
                    //yxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northeast of Scene.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);


                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x y
                    //xxx
                    //yxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize)
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the east of Scene{1} Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                        // If we're one region over -x -y
                        //yxx
                        //xxx
                        //xxx
                        if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                            == (regionConnections.X * (int)Constants.RegionSize))
                            && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                            == (regionConnections.Y * (int)Constants.RegionSize)))
                        {
                            Vector3 offset = Vector3.Zero;
                            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                        ((conn.X * (int)Constants.RegionSize)));
                            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                        ((conn.Y * (int)Constants.RegionSize)));

                            Vector3 extents = Vector3.Zero;
                            extents.Y = regionConnections.YEnd + conn.YEnd;
                            extents.X = conn.XEnd + conn.XEnd;

                            m_log.DebugFormat("Scene: {0} to the northeast of Scene{1} Offset: {2}. Extents:{3}",
                                              conn.RegionScene.RegionInfo.RegionName,
                                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                            connectedYN = true;
                            break;
                        }
                        */
                    #endregion

                    // If we're one region over +x y
                    //xxx
                    //xxy
                    //xxx


                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd
                        >= (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize)
                        >= (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(conn, regionConnections, scene);
                        break;
                    }

                    // If we're one region over x +y
                    //xyx
                    //xxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize)
                        >= (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                        >= (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        connectedYN = DoWorkForOneRegionOverXPlusY(conn, regionConnections, scene);
                        break;
                    }

                    // If we're one region over +x +y
                    //xxy
                    //xxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.YEnd
                        >= (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                        >= (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXPlusY(conn, regionConnections, scene);
                        break;

                    }
                }

                // If !connectYN means that this region is a root region
                if (!connectedYN)
                {
                    DoWorkForRootRegion(regionConnections, scene);

                }
            }
            // Set up infinite borders around the entire AABB of the combined ConnectedRegions
            AdjustLargeRegionBounds();
        }
        private void RegionLoadedDoWork(Scene scene)
        {
/*
 *          // For testing on a single instance
 *          if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
 *              return;
 *          //
 */

            RegionConnections newConn = new RegionConnections();

            newConn.ConnectedRegions  = new List <RegionData>();
            newConn.RegionScene       = scene;
            newConn.RegionLandChannel = scene.LandChannel;
            newConn.RegionId          = scene.RegionInfo.originRegionID;
            newConn.X    = scene.RegionInfo.RegionLocX;
            newConn.Y    = scene.RegionInfo.RegionLocY;
            newConn.XEnd = scene.RegionInfo.RegionSizeX;
            newConn.YEnd = scene.RegionInfo.RegionSizeX;

            lock (m_regions)
            {
                bool connectedYN = false;

                foreach (RegionConnections rootConn in m_regions.Values)
                {
                    #region commented

                    /*
                     * // If we're one region over +x +y
                     * //xxy
                     * //xxx
                     * //xxx
                     * if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd
                     *  == (regionConnections.X * (int)Constants.RegionSize))
                     *  && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                     *  == (regionConnections.Y * (int)Constants.RegionSize)))
                     * {
                     *  Vector3 offset = Vector3.Zero;
                     *  offset.X = (((regionConnections.X * (int) Constants.RegionSize)) -
                     *              ((conn.X * (int) Constants.RegionSize)));
                     *  offset.Y = (((regionConnections.Y * (int) Constants.RegionSize)) -
                     *              ((conn.Y * (int) Constants.RegionSize)));
                     *
                     *  Vector3 extents = Vector3.Zero;
                     *  extents.Y = regionConnections.YEnd + conn.YEnd;
                     *  extents.X = conn.XEnd + conn.XEnd;
                     *
                     *  m_log.DebugFormat("Scene: {0} to the northwest of Scene{1}.  Offset: {2}.  Extents:{3}",
                     *                    conn.RegionScene.RegionInfo.RegionName,
                     *                    regionConnections.RegionScene.RegionInfo.RegionName,
                     *                    offset, extents);
                     *
                     *  scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                     *
                     *  connectedYN = true;
                     *  break;
                     * }
                     */

                    /*
                     * //If we're one region over x +y
                     * //xxx
                     * //xxx
                     * //xyx
                     * if ((((int)conn.X * (int)Constants.RegionSize)
                     *  == (regionConnections.X * (int)Constants.RegionSize))
                     *  && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                     *  == (regionConnections.Y * (int)Constants.RegionSize)))
                     * {
                     *  Vector3 offset = Vector3.Zero;
                     *  offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                     *              ((conn.X * (int)Constants.RegionSize)));
                     *  offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                     *              ((conn.Y * (int)Constants.RegionSize)));
                     *
                     *  Vector3 extents = Vector3.Zero;
                     *  extents.Y = regionConnections.YEnd + conn.YEnd;
                     *  extents.X = conn.XEnd;
                     *
                     *  m_log.DebugFormat("Scene: {0} to the north of Scene{1}.  Offset: {2}. Extents:{3}",
                     *                    conn.RegionScene.RegionInfo.RegionName,
                     *                    regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
                     *
                     *  scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                     *  connectedYN = true;
                     *  break;
                     * }
                     */

                    /*
                     * // If we're one region over -x +y
                     * //xxx
                     * //xxx
                     * //yxx
                     * if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                     *  == (regionConnections.X * (int)Constants.RegionSize))
                     *  && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                     *  == (regionConnections.Y * (int)Constants.RegionSize)))
                     * {
                     *  Vector3 offset = Vector3.Zero;
                     *  offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                     *              ((conn.X * (int)Constants.RegionSize)));
                     *  offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                     *              ((conn.Y * (int)Constants.RegionSize)));
                     *
                     *  Vector3 extents = Vector3.Zero;
                     *  extents.Y = regionConnections.YEnd + conn.YEnd;
                     *  extents.X = conn.XEnd + conn.XEnd;
                     *
                     *  m_log.DebugFormat("Scene: {0} to the northeast of Scene.  Offset: {2}. Extents:{3}",
                     *                    conn.RegionScene.RegionInfo.RegionName,
                     *                    regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
                     *
                     *  scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                     *
                     *
                     *  connectedYN = true;
                     *  break;
                     * }
                     */

                    /*
                     * // If we're one region over -x y
                     * //xxx
                     * //yxx
                     * //xxx
                     * if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                     *  == (regionConnections.X * (int)Constants.RegionSize))
                     *  && (((int)conn.Y * (int)Constants.RegionSize)
                     *  == (regionConnections.Y * (int)Constants.RegionSize)))
                     * {
                     *  Vector3 offset = Vector3.Zero;
                     *  offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                     *              ((conn.X * (int)Constants.RegionSize)));
                     *  offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                     *              ((conn.Y * (int)Constants.RegionSize)));
                     *
                     *  Vector3 extents = Vector3.Zero;
                     *  extents.Y = regionConnections.YEnd;
                     *  extents.X = conn.XEnd + conn.XEnd;
                     *
                     *  m_log.DebugFormat("Scene: {0} to the east of Scene{1} Offset: {2}. Extents:{3}",
                     *                    conn.RegionScene.RegionInfo.RegionName,
                     *                    regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
                     *
                     *  scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                     *
                     *  connectedYN = true;
                     *  break;
                     * }
                     */

                    /*
                     *  // If we're one region over -x -y
                     *  //yxx
                     *  //xxx
                     *  //xxx
                     *  if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                     *      == (regionConnections.X * (int)Constants.RegionSize))
                     *      && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                     *      == (regionConnections.Y * (int)Constants.RegionSize)))
                     *  {
                     *      Vector3 offset = Vector3.Zero;
                     *      offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                     *                  ((conn.X * (int)Constants.RegionSize)));
                     *      offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                     *                  ((conn.Y * (int)Constants.RegionSize)));
                     *
                     *      Vector3 extents = Vector3.Zero;
                     *      extents.Y = regionConnections.YEnd + conn.YEnd;
                     *      extents.X = conn.XEnd + conn.XEnd;
                     *
                     *      m_log.DebugFormat("Scene: {0} to the northeast of Scene{1} Offset: {2}. Extents:{3}",
                     *                        conn.RegionScene.RegionInfo.RegionName,
                     *                        regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);
                     *
                     *      scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                     *
                     *      connectedYN = true;
                     *      break;
                     *  }
                     */
                    #endregion


                    // Check to see if this new region is adjacent to the root region.
                    // Note that we expect the regions to be combined from the root region outward
                    //    thus the requirement for the ordering in the configuration files.

                    // If we're one region over +x y (i.e. root region is to the west)
                    //xxx
                    //xxy
                    //xxx
                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }

                    // If we're one region over x +y (i.e. root region is to the south)
                    //xyx
                    //xxx
                    //xxx
                    if (rootConn.PosX >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }

                    // If we're one region over +x +y (i.e. root region is to the south-west)
                    //xxy
                    //xxx
                    //xxx
                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }
                }

                // If !connectYN means that this region is a root region
                if (!connectedYN)
                {
                    DoWorkForRootRegion(newConn, scene);
                }
            }
        }
        private bool DoWorkForOneRegionOverPlusXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = newConn.PosX - rootConn.PosX;
            offset.Y = newConn.PosY - rootConn.PosY;

            Vector3 extents = Vector3.Zero;

            // We do not want to inflate the extents for regions strictly to the NE of the root region, since this
            // would double count regions strictly to the north and east that have already been added.
//            extents.Y = regionConnections.YEnd + conn.YEnd;
//            extents.X = regionConnections.XEnd + conn.XEnd;
//            conn.UpdateExtents(extents);

            extents.Y = rootConn.YEnd;
            extents.X = rootConn.XEnd;

            scene.BordersLocked = true;
            rootConn.RegionScene.BordersLocked = true;

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;

            rootConn.ConnectedRegions.Add(ConnectedRegion);

            m_log.DebugFormat(
                "[REGION COMBINER MODULE]: Region {0} is to the southwest of Scene {1}, Offset: {2}, Extents: {3}",
                rootConn.RegionScene.RegionInfo.RegionName,
                newConn.RegionScene.RegionInfo.RegionName, offset, extents);

            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);

            lock (rootConn.RegionScene.NorthBorders)
            {
                if (rootConn.RegionScene.NorthBorders.Count == 1)// &&  2)
                {
                    //compound border
                    // already locked above
                    rootConn.RegionScene.NorthBorders[0].BorderLine.Z += (int)Constants.RegionSize;

                    lock (rootConn.RegionScene.EastBorders)
                        rootConn.RegionScene.EastBorders[0].BorderLine.Y += (int)Constants.RegionSize;

                    lock (rootConn.RegionScene.WestBorders)
                        rootConn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                }
            }

            lock (scene.SouthBorders)
            {
                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocY - rootConn.RegionScene.RegionInfo.RegionLocY) * (int)Constants.RegionSize); //auto teleport south
                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
            }

            lock (rootConn.RegionScene.EastBorders)
            {
                if (rootConn.RegionScene.EastBorders.Count == 1)// && conn.RegionScene.EastBorders.Count == 2)
                {

                    rootConn.RegionScene.EastBorders[0].BorderLine.Z += (int)Constants.RegionSize;

                    lock (rootConn.RegionScene.NorthBorders)
                        rootConn.RegionScene.NorthBorders[0].BorderLine.Y += (int)Constants.RegionSize;

                    lock (rootConn.RegionScene.SouthBorders)
                        rootConn.RegionScene.SouthBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                }
            }

            lock (scene.WestBorders)
            {
                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocX - rootConn.RegionScene.RegionInfo.RegionLocX) * (int)Constants.RegionSize); //auto teleport West
                scene.WestBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
                scene.WestBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
            }

            /*
                                    else
                                    {
                                        conn.RegionScene.NorthBorders[0].BorderLine.Z += (int)Constants.RegionSize;
                                        conn.RegionScene.EastBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                                        conn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
                                        scene.SouthBorders[0].BorderLine.Z += (int)Constants.RegionSize; //auto teleport south
                                    }
            */


            // Reset Terrain..  since terrain normally loads first.
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            scene.BordersLocked = false;
            rootConn.RegionScene.BordersLocked = false;

            if (rootConn.ClientEventForwarder != null)
                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            return true;

            //scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset,extents);
        }
        private bool DoWorkForOneRegionOverXPlusY(RegionConnections rootConn, RegionConnections newConn, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = newConn.PosX - rootConn.PosX;
            offset.Y = newConn.PosY - rootConn.PosY;

            Vector3 extents = Vector3.Zero;
            extents.Y = newConn.YEnd + rootConn.YEnd;
            extents.X = rootConn.XEnd;
            rootConn.UpdateExtents(extents);

            scene.BordersLocked = true;
            rootConn.RegionScene.BordersLocked = true;

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;
            rootConn.ConnectedRegions.Add(ConnectedRegion);

            m_log.DebugFormat(
                "[REGION COMBINER MODULE]: Root region {0} is to the south of region {1}, Offset: {2}, Extents: {3}",
                rootConn.RegionScene.RegionInfo.RegionName,
                newConn.RegionScene.RegionInfo.RegionName, offset, extents);

            rootConn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
            scene.PhysicsScene.Combine(rootConn.RegionScene.PhysicsScene, offset, Vector3.Zero);

            lock (rootConn.RegionScene.NorthBorders)
                rootConn.RegionScene.NorthBorders[0].BorderLine.Z += (int)Constants.RegionSize;

            lock (rootConn.RegionScene.EastBorders)
                rootConn.RegionScene.EastBorders[0].BorderLine.Y += (int)Constants.RegionSize;

            lock (rootConn.RegionScene.WestBorders)
                rootConn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;

            lock (scene.SouthBorders)
            {
                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocY - rootConn.RegionScene.RegionInfo.RegionLocY) * (int)Constants.RegionSize); //auto teleport south
                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
            }

            // Reset Terrain..  since terrain normally loads first.
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
            //conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());

            scene.BordersLocked = false;
            rootConn.RegionScene.BordersLocked = false;

            if (rootConn.ClientEventForwarder != null)
                rootConn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            return true;
        }
示例#18
0
 public RegionCombinerClientEventForwarder(RegionConnections rootScene)
 {
     m_rootScene = rootScene.RegionScene;
 }
示例#19
0
        private bool DoWorkForOneRegionOverPlusXY(RegionConnections conn, RegionConnections regionConnections, Scene scene)
        {
            Vector3 offset = Vector3.Zero;
            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                        ((conn.X * (int)Constants.RegionSize)));
            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                        ((conn.Y * (int)Constants.RegionSize)));

            Vector3 extents = Vector3.Zero;
            extents.Y = conn.YEnd;
            extents.X = conn.XEnd + regionConnections.XEnd;

            conn.UpdateExtents(extents);

            m_log.DebugFormat("Scene: {0} to the west of Scene{1} Offset: {2}. Extents:{3}",
                              conn.RegionScene.RegionInfo.RegionName,
                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

            scene.BordersLocked = true;
            conn.RegionScene.BordersLocked = true;

            RegionData ConnectedRegion = new RegionData();
            ConnectedRegion.Offset = offset;
            ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
            ConnectedRegion.RegionScene = scene;
            conn.ConnectedRegions.Add(ConnectedRegion);

            // Inform root region Physics about the extents of this region
            conn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);

            // Inform Child region that it needs to forward it's terrain to the root region
            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, Vector3.Zero);

            // Extend the borders as appropriate
            lock (conn.RegionScene.EastBorders)
                conn.RegionScene.EastBorders[0].BorderLine.Z += (int)Constants.RegionSize;

            lock (conn.RegionScene.NorthBorders)
                conn.RegionScene.NorthBorders[0].BorderLine.Y += (int)Constants.RegionSize;

            lock (conn.RegionScene.SouthBorders)
                conn.RegionScene.SouthBorders[0].BorderLine.Y += (int)Constants.RegionSize;

            lock (scene.WestBorders)
            {


                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocX - conn.RegionScene.RegionInfo.RegionLocX) * (int)Constants.RegionSize); //auto teleport West

                // Trigger auto teleport to root region
                scene.WestBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
                scene.WestBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
            }

            // Reset Terrain..  since terrain loads before we get here, we need to load 
            // it again so it loads in the root region

            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());

            // Unlock borders
            conn.RegionScene.BordersLocked = false;
            scene.BordersLocked = false;

            // Create a client event forwarder and add this region's events to the root region.
            if (conn.ClientEventForwarder != null)
                conn.ClientEventForwarder.AddSceneToEventForwarding(scene);

            return true;
        }
        private void DistributeCoarseLocationUpdates(List <Vector3> locations, List <UUID> uuids,
                                                     RegionConnections connectiondata, ScenePresence rootPresence)
        {
            RegionData[] rdata = connectiondata.ConnectedRegions.ToArray();
            //List<IClientAPI> clients = new List<IClientAPI>();
            Dictionary <Vector2, RegionCoarseLocationStruct> updates = new Dictionary <Vector2, RegionCoarseLocationStruct>();

            // Root Region entry
            RegionCoarseLocationStruct rootupdatedata = new RegionCoarseLocationStruct();

            rootupdatedata.Locations = new List <Vector3>();
            rootupdatedata.Uuids     = new List <UUID>();
            rootupdatedata.Offset    = Vector2.Zero;

            rootupdatedata.UserAPI = rootPresence.ControllingClient;

            if (rootupdatedata.UserAPI != null)
            {
                updates.Add(Vector2.Zero, rootupdatedata);
            }

            //Each Region needs an entry or we will end up with dead minimap dots
            foreach (RegionData regiondata in rdata)
            {
                Vector2 offset = new Vector2(regiondata.Offset.X, regiondata.Offset.Y);
                RegionCoarseLocationStruct updatedata = new RegionCoarseLocationStruct();
                updatedata.Locations = new List <Vector3>();
                updatedata.Uuids     = new List <UUID>();
                updatedata.Offset    = offset;

                if (offset == Vector2.Zero)
                {
                    updatedata.UserAPI = rootPresence.ControllingClient;
                }
                else
                {
                    updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);
                }

                if (updatedata.UserAPI != null)
                {
                    updates.Add(offset, updatedata);
                }
            }

            // go over the locations and assign them to an IClientAPI
            for (int i = 0; i < locations.Count; i++)
            //{locations[i]/(int) Constants.RegionSize;
            {
                Vector3 pPosition = new Vector3((int)locations[i].X / (int)Constants.RegionSize,
                                                (int)locations[i].Y / (int)Constants.RegionSize, locations[i].Z);
                Vector2 offset = new Vector2(pPosition.X * (int)Constants.RegionSize,
                                             pPosition.Y * (int)Constants.RegionSize);

                if (!updates.ContainsKey(offset))
                {
                    // This shouldn't happen
                    RegionCoarseLocationStruct updatedata = new RegionCoarseLocationStruct();
                    updatedata.Locations = new List <Vector3>();
                    updatedata.Uuids     = new List <UUID>();
                    updatedata.Offset    = offset;

                    if (offset == Vector2.Zero)
                    {
                        updatedata.UserAPI = rootPresence.ControllingClient;
                    }
                    else
                    {
                        updatedata.UserAPI = LocateUsersChildAgentIClientAPI(offset, rootPresence.UUID, rdata);
                    }

                    updates.Add(offset, updatedata);
                }

                updates[offset].Locations.Add(locations[i]);
                updates[offset].Uuids.Add(uuids[i]);
            }

            // Send out the CoarseLocationupdates from their respective client connection based on where the avatar is
            foreach (Vector2 offset in updates.Keys)
            {
                if (updates[offset].UserAPI != null)
                {
                    updates[offset].UserAPI.SendCoarseLocationUpdate(updates[offset].Uuids, updates[offset].Locations);
                }
            }
        }
示例#21
0
        private void DoWorkForRootRegion(RegionConnections regionConnections, Scene scene)
        {
            RegionData rdata = new RegionData();
            rdata.Offset = Vector3.Zero;
            rdata.RegionId = scene.RegionInfo.originRegionID;
            rdata.RegionScene = scene;
            // save it's land channel
            regionConnections.RegionLandChannel = scene.LandChannel;

            // Substitue our landchannel
            RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.LandChannel,
                                                            regionConnections.ConnectedRegions);
            scene.LandChannel = lnd;
            // Forward the permissions modules of each of the connected regions to the root region
            lock (m_regions)
            {
                foreach (RegionData r in regionConnections.ConnectedRegions)
                {
                    ForwardPermissionRequests(regionConnections, r.RegionScene);
                }
            }
            // Create the root region's Client Event Forwarder
            regionConnections.ClientEventForwarder = new RegionCombinerClientEventForwarder(regionConnections);

            // Sets up the CoarseLocationUpdate forwarder for this root region
            scene.EventManager.OnNewPresence += SetCourseLocationDelegate;

            // Adds this root region to a dictionary of regions that are connectable
            m_regions.Add(scene.RegionInfo.originRegionID, regionConnections);
        }
        private void RegionLoadedDoWork(Scene scene)
        {
/* 
            // For testing on a single instance
            if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
                return;
            // 
*/

            RegionConnections newConn = new RegionConnections();
            newConn.ConnectedRegions = new List<RegionData>();
            newConn.RegionScene = scene;
            newConn.RegionLandChannel = scene.LandChannel;
            newConn.RegionId = scene.RegionInfo.originRegionID;
            newConn.X = scene.RegionInfo.RegionLocX;
            newConn.Y = scene.RegionInfo.RegionLocY;
            newConn.XEnd = scene.RegionInfo.RegionSizeX;
            newConn.YEnd = scene.RegionInfo.RegionSizeX;

            lock (m_regions)
            {
                bool connectedYN = false;

                foreach (RegionConnections rootConn in m_regions.Values)
                {
                    #region commented
                    /*
                    // If we're one region over +x +y
                    //xxy
                    //xxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd 
                        == (regionConnections.X * (int)Constants.RegionSize)) 
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd 
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int) Constants.RegionSize)) -
                                    ((conn.X * (int) Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int) Constants.RegionSize)) -
                                    ((conn.Y * (int) Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northwest of Scene{1}.  Offset: {2}.  Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName,
                                          offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                            
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    //If we're one region over x +y
                    //xxx
                    //xxx
                    //xyx
                    if ((((int)conn.X * (int)Constants.RegionSize)
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the north of Scene{1}.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);
                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x +y
                    //xxx
                    //xxx
                    //yxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize) - conn.YEnd
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd + conn.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the northeast of Scene.  Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);


                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                    // If we're one region over -x y
                    //xxx
                    //yxx
                    //xxx
                    if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                        == (regionConnections.X * (int)Constants.RegionSize))
                        && (((int)conn.Y * (int)Constants.RegionSize)
                        == (regionConnections.Y * (int)Constants.RegionSize)))
                    {
                        Vector3 offset = Vector3.Zero;
                        offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                    ((conn.X * (int)Constants.RegionSize)));
                        offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                    ((conn.Y * (int)Constants.RegionSize)));

                        Vector3 extents = Vector3.Zero;
                        extents.Y = regionConnections.YEnd;
                        extents.X = conn.XEnd + conn.XEnd;

                        m_log.DebugFormat("Scene: {0} to the east of Scene{1} Offset: {2}. Extents:{3}",
                                          conn.RegionScene.RegionInfo.RegionName,
                                          regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                        scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                        connectedYN = true;
                        break;
                    }
                    */

                    /*
                        // If we're one region over -x -y
                        //yxx
                        //xxx
                        //xxx
                        if ((((int)conn.X * (int)Constants.RegionSize) - conn.XEnd
                            == (regionConnections.X * (int)Constants.RegionSize))
                            && (((int)conn.Y * (int)Constants.RegionSize) + conn.YEnd
                            == (regionConnections.Y * (int)Constants.RegionSize)))
                        {
                            Vector3 offset = Vector3.Zero;
                            offset.X = (((regionConnections.X * (int)Constants.RegionSize)) -
                                        ((conn.X * (int)Constants.RegionSize)));
                            offset.Y = (((regionConnections.Y * (int)Constants.RegionSize)) -
                                        ((conn.Y * (int)Constants.RegionSize)));

                            Vector3 extents = Vector3.Zero;
                            extents.Y = regionConnections.YEnd + conn.YEnd;
                            extents.X = conn.XEnd + conn.XEnd;

                            m_log.DebugFormat("Scene: {0} to the northeast of Scene{1} Offset: {2}. Extents:{3}",
                                              conn.RegionScene.RegionInfo.RegionName,
                                              regionConnections.RegionScene.RegionInfo.RegionName, offset, extents);

                            scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, extents);

                            connectedYN = true;
                            break;
                        }
                        */
                    #endregion


                    // Check to see if this new region is adjacent to the root region.
                    // Note that we expect the regions to be combined from the root region outward
                    //    thus the requirement for the ordering in the configuration files.

                    // If we're one region over +x y (i.e. root region is to the west)
                    //xxx
                    //xxy
                    //xxx
                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }

                    // If we're one region over x +y (i.e. root region is to the south)
                    //xyx
                    //xxx
                    //xxx
                    if (rootConn.PosX >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }

                    // If we're one region over +x +y (i.e. root region is to the south-west)
                    //xxy
                    //xxx
                    //xxx
                    if (rootConn.PosX + rootConn.XEnd >= newConn.PosX && rootConn.PosY + rootConn.YEnd >= newConn.PosY)
                    {
                        connectedYN = DoWorkForOneRegionOverPlusXY(rootConn, newConn, scene);
                        break;
                    }
                }

                // If !connectYN means that this region is a root region
                if (!connectedYN)
                {
                    DoWorkForRootRegion(newConn, scene);
                }
            }
        }
示例#23
0
        public void ForwardPermissionRequests(RegionConnections BigRegion, Scene VirtualRegion)
        {
            if (BigRegion.PermissionModule == null)
                BigRegion.PermissionModule = new RegionCombinerPermissionModule(BigRegion.RegionScene);

            VirtualRegion.Permissions.OnBypassPermissions += BigRegion.PermissionModule.BypassPermissions;
            VirtualRegion.Permissions.OnSetBypassPermissions += BigRegion.PermissionModule.SetBypassPermissions;
            VirtualRegion.Permissions.OnPropagatePermissions += BigRegion.PermissionModule.PropagatePermissions;
            VirtualRegion.Permissions.OnGenerateClientFlags += BigRegion.PermissionModule.GenerateClientFlags;
            VirtualRegion.Permissions.OnAbandonParcel += BigRegion.PermissionModule.CanAbandonParcel;
            VirtualRegion.Permissions.OnReclaimParcel += BigRegion.PermissionModule.CanReclaimParcel;
            VirtualRegion.Permissions.OnDeedParcel += BigRegion.PermissionModule.CanDeedParcel;
            VirtualRegion.Permissions.OnDeedObject += BigRegion.PermissionModule.CanDeedObject;
            VirtualRegion.Permissions.OnIsGod += BigRegion.PermissionModule.IsGod;
            VirtualRegion.Permissions.OnDuplicateObject += BigRegion.PermissionModule.CanDuplicateObject;
            VirtualRegion.Permissions.OnDeleteObject += BigRegion.PermissionModule.CanDeleteObject; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnEditObject += BigRegion.PermissionModule.CanEditObject; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnEditParcel += BigRegion.PermissionModule.CanEditParcel; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnInstantMessage += BigRegion.PermissionModule.CanInstantMessage;
            VirtualRegion.Permissions.OnInventoryTransfer += BigRegion.PermissionModule.CanInventoryTransfer; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnIssueEstateCommand += BigRegion.PermissionModule.CanIssueEstateCommand; //FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnMoveObject += BigRegion.PermissionModule.CanMoveObject; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnObjectEntry += BigRegion.PermissionModule.CanObjectEntry;
            VirtualRegion.Permissions.OnReturnObject += BigRegion.PermissionModule.CanReturnObject; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnRezObject += BigRegion.PermissionModule.CanRezObject; //MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnRunConsoleCommand += BigRegion.PermissionModule.CanRunConsoleCommand;
            VirtualRegion.Permissions.OnRunScript += BigRegion.PermissionModule.CanRunScript; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCompileScript += BigRegion.PermissionModule.CanCompileScript;
            VirtualRegion.Permissions.OnSellParcel += BigRegion.PermissionModule.CanSellParcel;
            VirtualRegion.Permissions.OnTakeObject += BigRegion.PermissionModule.CanTakeObject;
            VirtualRegion.Permissions.OnTakeCopyObject += BigRegion.PermissionModule.CanTakeCopyObject;
            VirtualRegion.Permissions.OnTerraformLand += BigRegion.PermissionModule.CanTerraformLand;
            VirtualRegion.Permissions.OnLinkObject += BigRegion.PermissionModule.CanLinkObject; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDelinkObject += BigRegion.PermissionModule.CanDelinkObject; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnBuyLand += BigRegion.PermissionModule.CanBuyLand; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnViewNotecard += BigRegion.PermissionModule.CanViewNotecard; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnViewScript += BigRegion.PermissionModule.CanViewScript; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditNotecard += BigRegion.PermissionModule.CanEditNotecard; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditScript += BigRegion.PermissionModule.CanEditScript; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCreateObjectInventory += BigRegion.PermissionModule.CanCreateObjectInventory; //NOT IMPLEMENTED HERE 
            VirtualRegion.Permissions.OnEditObjectInventory += BigRegion.PermissionModule.CanEditObjectInventory;//MAYBE FULLY IMPLEMENTED
            VirtualRegion.Permissions.OnCopyObjectInventory += BigRegion.PermissionModule.CanCopyObjectInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDeleteObjectInventory += BigRegion.PermissionModule.CanDeleteObjectInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnResetScript += BigRegion.PermissionModule.CanResetScript;
            VirtualRegion.Permissions.OnCreateUserInventory += BigRegion.PermissionModule.CanCreateUserInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnCopyUserInventory += BigRegion.PermissionModule.CanCopyUserInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnEditUserInventory += BigRegion.PermissionModule.CanEditUserInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnDeleteUserInventory += BigRegion.PermissionModule.CanDeleteUserInventory; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnTeleport += BigRegion.PermissionModule.CanTeleport; //NOT YET IMPLEMENTED
            VirtualRegion.Permissions.OnUseObjectReturn += BigRegion.PermissionModule.CanUseObjectReturn; //NOT YET IMPLEMENTED
        }
        private void RegionLoadedDoWork(Scene scene)
        {
            lock (m_startingScenes)
                m_startingScenes.Add(scene.RegionInfo.originRegionID, scene);

            // Give each region a standard set of non-infinite borders
            Border northBorder = new Border();
            northBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, (int)Constants.RegionSize);  //<---
            northBorder.CrossDirection = Cardinals.N;
            scene.NorthBorders[0] = northBorder;

            Border southBorder = new Border();
            southBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, 0);    //--->
            southBorder.CrossDirection = Cardinals.S;
            scene.SouthBorders[0] = southBorder;

            Border eastBorder = new Border();
            eastBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, (int)Constants.RegionSize);   //<---
            eastBorder.CrossDirection = Cardinals.E;
            scene.EastBorders[0] = eastBorder;

            Border westBorder = new Border();
            westBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, 0);     //--->
            westBorder.CrossDirection = Cardinals.W;
            scene.WestBorders[0] = westBorder;

            RegionConnections regionConnections = new RegionConnections();
            regionConnections.ConnectedRegions = new List<RegionData>();
            regionConnections.RegionScene = scene;
            regionConnections.RegionLandChannel = scene.LandChannel;
            regionConnections.RegionId = scene.RegionInfo.originRegionID;
            regionConnections.X = scene.RegionInfo.RegionLocX;
            regionConnections.Y = scene.RegionInfo.RegionLocY;
            regionConnections.XExtend = (int)Constants.RegionSize;
            regionConnections.YExtend = (int)Constants.RegionSize;


            if (m_nRegions == 0)
            {
                // this is root region
                regionConnections.XExtend *= m_numberCombinedRegionsX;
                regionConnections.YExtend *= m_numberCombinedRegionsY;

                m_rootScene = scene;
                m_rootConnection = regionConnections;

                // save it's land channel
                regionConnections.RegionLandChannel = scene.LandChannel;

                scene.RootScene = null;
                scene.RegionInfo.CombinedRegionHandle = 0;

                Vector3 extents;
                extents.X = regionConnections.XExtend;
                extents.Y = regionConnections.YExtend;
                extents.Z = 0;

                scene.RegionInfo.RegionSizeX = (uint)extents.X;
                scene.RegionInfo.RegionSizeY = (uint)extents.Y;

//                scene.PhysicsScene.Combine(null, Vector3.Zero, extents);

                lock (scene.SouthBorders)
                    scene.SouthBorders[0].BorderLine.Y = regionConnections.XExtend;

                lock (scene.WestBorders)
                    scene.WestBorders[0].BorderLine.Y = regionConnections.YExtend;

                lock (scene.EastBorders)
                {
                    scene.EastBorders[0].BorderLine.Z = regionConnections.XExtend;
                    scene.EastBorders[0].BorderLine.Y = regionConnections.YExtend;
                }

                lock (scene.NorthBorders)
                {
                    scene.NorthBorders[0].BorderLine.Z = regionConnections.YExtend;
                    scene.NorthBorders[0].BorderLine.Y = regionConnections.XExtend;
                }

                // Substitue our landchannel

                RegionData rdata = new RegionData();
                rdata.Offset = Vector3.Zero;
                rdata.RegionId = scene.RegionInfo.originRegionID;
                rdata.RegionScene = scene;

                RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.LandChannel,
                                                                regionConnections.ConnectedRegions);

                scene.LandChannel = lnd;
                // Forward the permissions modules of each of the connected regions to the root region
                // Create the root region's Client Event Forwarder
                regionConnections.ClientEventForwarder = new RegionCombinerClientEventForwarder(regionConnections);

                // Sets up the CoarseLocationUpdate forwarder for this root region
                scene.EventManager.OnNewPresence += SetCourseLocationDelegate;

                // Adds this root region to a dictionary of regions that are connectable
                m_regions.Add(scene.RegionInfo.originRegionID, regionConnections);
               
            }

            else if (m_rootScene != null)
            {
                scene.RootScene = m_rootScene;
                scene.RegionInfo.CombinedRegionHandle = m_rootScene.RegionInfo.RegionHandle;

                Vector3 offset = Vector3.Zero;
                offset.X = ((int)regionConnections.X - (int)m_rootConnection.X) * Constants.RegionSize;
                offset.Y = ((int)regionConnections.Y - (int)m_rootConnection.Y) * Constants.RegionSize;

                RegionData ConnectedRegion = new RegionData();
                ConnectedRegion.Offset = offset;
                ConnectedRegion.RegionId = scene.RegionInfo.originRegionID;
                ConnectedRegion.RegionScene = scene;
                m_rootConnection.ConnectedRegions.Add(ConnectedRegion);

                scene.Physics_Enabled = false;
                scene.Scripts_Enabled = false;


                m_rootScene.PhysicsScene.CombineTerrain(scene.Heightmap.GetFloatsSerialised(),offset);

                scene.EventManager.OnNewPresence += SetCourseLocationDelegate;
                // Create a client event forwarder and add this region's events to the root region.
                
                if (m_rootConnection.ClientEventForwarder != null)
                    m_rootConnection.ClientEventForwarder.AddSceneToEventForwarding(scene);
            }

            m_nRegions++;

            if (m_nRegions == m_nRegionsToLoad)
            {
                // final work
                lock (m_regions)
                {
                    foreach (RegionData r in regionConnections.ConnectedRegions)
                    {
                        ForwardPermissionRequests(regionConnections, r.RegionScene);
                    }
                }
            }

            AdjustLargeRegionBounds();
            return;

        }