public static void GetMeshLODByteCounts(byte[] mesh_data, out int hibytes, out int midbytes, out int lowbytes, out int lowestbytes)
{
hibytes = 0;
midbytes = 0;
lowbytes = 0;
lowestbytes = 0;
try
{
long start = 0;
OSDMap lodData = SceneObjectPartMeshCost.TryExtractOSDMapFromLLSDBinary(ref start, mesh_data);
// Stash the data we need to recalculate streaming cost on scale changes.
if (lodData.ContainsKey("high_lod"))
{
hibytes = ((OSDMap)lodData["high_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("medium_lod"))
{
midbytes = ((OSDMap)lodData["medium_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("low_lod"))
{
lowbytes = ((OSDMap)lodData["low_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("lowest_lod"))
{
lowestbytes = ((OSDMap)lodData["lowest_lod"])["size"].AsInteger();
}
}
catch (Exception e)
{
m_log.ErrorFormat("[MESH]: exception extracting LOD ByteCounts: {0}", e);
}
}
/// <summary>
/// Receive parcel voice cap
/// </summary>
/// <param name="client"></param>
/// <param name="result"></param>
/// <param name="error"></param>
void pCap_OnComplete(OpenMetaverse.Http.CapsClient client,
OpenMetaverse.StructuredData.OSD result,
Exception error)
{
parcelCap.OnComplete -=
new OpenMetaverse.Http.CapsClient.CompleteCallback(pCap_OnComplete);
parcelCap = null;
if (error != null)
{
Logger.Log("Region voice cap " + error.Message, Helpers.LogLevel.Error);
return;
}
OpenMetaverse.StructuredData.OSDMap pMap = result as OpenMetaverse.StructuredData.OSDMap;
regionName = pMap["region_name"].AsString();
ReportConnectionState(ConnectionState.RegionCapAvailable);
if (pMap.ContainsKey("voice_credentials"))
{
OpenMetaverse.StructuredData.OSDMap cred =
pMap["voice_credentials"] as OpenMetaverse.StructuredData.OSDMap;
if (cred.ContainsKey("channel_uri"))
{
spatialUri = cred["channel_uri"].AsString();
}
if (cred.ContainsKey("channel_credentials"))
{
spatialCredentials = cred["channel_credentials"].AsString();
}
}
if (spatialUri == null || spatialUri == "")
{
// "No voice chat allowed here");
return;
}
Logger.Log("Voice connecting for region " + regionName, Helpers.LogLevel.Info);
// STEP 5
int reqId = SessionCreate(
accountHandle,
spatialUri, // uri
"", // Channel name seems to be always null
spatialCredentials, // spatialCredentials, // session password
true, // Join Audio
false, // Join Text
"");
if (reqId < 0)
{
Logger.Log("Voice Session ReqID " + reqId.ToString(), Helpers.LogLevel.Error);
}
}
/// <summary>
/// Sends the mapitem response to the IClientAPI
/// </summary>
/// <param name="response">The OSDMap Response for the mapitem</param>
private void RequestMapItemsCompleted(IAsyncResult iar)
{
AsyncResult result = (AsyncResult)iar;
RequestMapItemsDelegate icon = (RequestMapItemsDelegate)result.AsyncDelegate;
OSDMap response = (OSDMap)icon.EndInvoke(iar);
Interlocked.Decrement(ref nAsyncRequests);
if (!response.ContainsKey("requestID"))
{
return;
}
UUID requestID = response["requestID"].AsUUID();
if (requestID != UUID.Zero)
{
MapRequestState mrs = new MapRequestState();
mrs.agentID = UUID.Zero;
lock (m_openRequests)
{
if (m_openRequests.ContainsKey(requestID))
{
mrs = m_openRequests[requestID];
m_openRequests.Remove(requestID);
}
}
if (mrs.agentID != UUID.Zero)
{
ScenePresence av = null;
m_scene.TryGetScenePresence(mrs.agentID, out av);
if (av != null)
{
if (response.ContainsKey(mrs.itemtype.ToString()))
{
List <mapItemReply> returnitems = new List <mapItemReply>();
OSDArray itemarray = (OSDArray)response[mrs.itemtype.ToString()];
for (int i = 0; i < itemarray.Count; i++)
{
OSDMap mapitem = (OSDMap)itemarray[i];
mapItemReply mi = new mapItemReply();
mi.x = (uint)mapitem["X"].AsInteger();
mi.y = (uint)mapitem["Y"].AsInteger();
mi.id = mapitem["ID"].AsUUID();
mi.Extra = mapitem["Extra"].AsInteger();
mi.Extra2 = mapitem["Extra2"].AsInteger();
mi.name = mapitem["Name"].AsString();
returnitems.Add(mi);
}
av.ControllingClient.SendMapItemReply(returnitems.ToArray(), mrs.itemtype, mrs.flags);
}
}
}
}
}
public void Add(string key, string value, string desc)
{
string lkey = key.ToLower();
lock (m_paramDescription) {
if (m_paramDescription.ContainsKey(lkey))
{
m_paramDescription.Remove(lkey);
}
m_paramDescription.Add(lkey, new OMVSD.OSDString(desc));
Add(lkey, value);
}
}
public string RenderMaterialsPostCap(string request, UUID agentID)
{
OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
OSDArray respArr = new OSDArray();
if (req.ContainsKey("Zipped"))
{
byte[] inBytes = req["Zipped"].AsBinary();
try
{
OSD osd = ZDecompressBytesToOsd(inBytes);
if (osd == null)
{
m_log.Warn("[MaterialsModule]: Decoded Materials request is empty");
}
else if (osd is OSDArray) // assume array of MaterialIDs designating requested material entries
{
ReturnRequestedMaterials(ref respArr, osd as OSDArray);
}
else if (osd is OSDMap) // request to assign a material
{
AssignRequestedMaterials(osd as OSDMap, agentID);
}
}
catch (Exception e)
{
m_log.Warn("[RenderMaterials]: exception decoding zipped CAP payload: " + e.ToString());
}
}
resp["Zipped"] = ZCompressOSD(respArr, false);
return(OSDParser.SerializeLLSDXmlString(resp));
}
private OMVSD.OSD GetHandler(RestHandler handler, Uri uri, String after)
{
OMVSD.OSDMap ret = new OMVSD.OSDMap();
string lastDate = "xx";
lock (m_chats) {
while (m_chats.Count > 0)
{
ChatEntry ce = m_chats.Dequeue();
string dateString = ce.time.ToString("yyyyMMddhhmmssfff");
OMVSD.OSDMap chat = new OMVSD.OSDMap();
chat.Add("Time", new OMVSD.OSDString(dateString));
chat.Add("From", new OMVSD.OSDString(ce.fromName));
chat.Add("Message", new OMVSD.OSDString(ce.message));
chat.Add("Type", new OMVSD.OSDString(ce.chatTypeString));
chat.Add("EntryType", new OMVSD.OSDString(ChatEntryTypeString[(int)ce.chatEntryType]));
chat.Add("Position", new OMVSD.OSDString(ce.position.ToString()));
if (ce.ownerID != null)
{
chat.Add("OwnerID", new OMVSD.OSDString(ce.ownerID.ToString()));
}
while (ret.ContainsKey(dateString))
{
dateString += "1";
}
ret.Add(dateString, chat);
lastDate = dateString;
}
}
return(ret);
}
public static void GetMeshVertexCount(byte[] data, out int vertex_count)
{
vertex_count = 0;
try
{
long start = 0;
OSDMap map = TryExtractOSDMapFromLLSDBinary(ref start, data);
if (map.ContainsKey("high_lod"))
{
map = (OSDMap)map["high_lod"];
OSDArray lod_data = DecodeMeshLODArray(data, start, map);
foreach (OSD subMeshOsd in lod_data)
{
// We get a list of faces. Sum each "face"
if (subMeshOsd is OSDMap)
{
vertex_count += DecodeMeshFace(subMeshOsd as OSDMap);
}
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[MESH]: exception meshing object: {0}", e);
vertex_count = 0;
}
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
if (!m_Enabled)
{
return;
}
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
}
else
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
// Detaching attachments doesn't work for HG visitors,
// so I'm giving that up.
//Util.FireAndForget(delegate { DetachAttachments(agentID); });
}
else
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
}
/// <summary>
/// Handle completion of main voice cap request.
/// </summary>
/// <param name="client"></param>
/// <param name="result"></param>
/// <param name="error"></param>
void cClient_OnComplete(OpenMetaverse.Http.CapsClient client,
OpenMetaverse.StructuredData.OSD result,
Exception error)
{
if (error != null)
{
Logger.Log("Voice cap error " + error.Message, Helpers.LogLevel.Error);
return;
}
Logger.Log("Voice provisioned", Helpers.LogLevel.Info);
ReportConnectionState(ConnectionState.Provisioned);
OpenMetaverse.StructuredData.OSDMap pMap = result as OpenMetaverse.StructuredData.OSDMap;
// We can get back 4 interesting values:
// voice_sip_uri_hostname
// voice_account_server_name (actually a full URI)
// username
// password
if (pMap.ContainsKey("voice_sip_uri_hostname"))
{
sipServer = pMap["voice_sip_uri_hostname"].AsString();
}
if (pMap.ContainsKey("voice_account_server_name"))
{
acctServer = pMap["voice_account_server_name"].AsString();
}
voiceUser = pMap["username"].AsString();
voicePassword = pMap["password"].AsString();
// Start the SLVoice daemon
slvoicePath = GetVoiceDaemonPath();
// Test if the executable exists
if (!System.IO.File.Exists(slvoicePath))
{
Logger.Log("SLVoice is missing", Helpers.LogLevel.Error);
return;
}
// STEP 1
StartDaemon(slvoicePath, slvoiceArgs);
}
/// <summary>
/// Assign The requested materials to the specified part(s).
/// </summary>
/// <param name="materialsFromViewer"></param>
private void AssignRequestedMaterials(OSDMap materialsFromViewer, UUID agentID)
{
if (!(materialsFromViewer.ContainsKey("FullMaterialsPerFace") &&
(materialsFromViewer["FullMaterialsPerFace"] is OSDArray)))
{
m_log.Warn("[RenderMaterials]: AssignRequestedMaterials - FullMaterialsPerFace not defined or incorrect type");
return;
}
OSDArray mats = materialsFromViewer["FullMaterialsPerFace"] as OSDArray;
foreach (OSDMap matsMap in mats)
{
uint matLocalID = 0;
int face = -1;
OSDMap matData = null;
try
{
matLocalID = matsMap["ID"].AsUInteger();
if (matsMap.ContainsKey("Face"))
{
face = matsMap["Face"].AsInteger();
}
if (matsMap.ContainsKey("Material"))
{
matData = matsMap["Material"] as OSDMap;
}
}
catch (Exception e)
{
m_log.Warn("[RenderMaterials]: cannot decode material from matsMap: " + e.Message);
continue;
}
/// Look up the scene object this material pertains to.
var sop = m_scene.GetSceneObjectPart(matLocalID);
if (sop == null)
{
m_log.Warn("[RenderMaterials]: null SOP for localId: " + matLocalID.ToString());
continue;
}
// Make sure we can modify it
if (m_scene.Permissions.CanEditObject(sop.ParentGroup.UUID, agentID, (uint)PermissionMask.Modify) == false)
{
m_log.WarnFormat("[RenderMaterials]: User {0} can't edit object {1} {2}",
agentID, sop.ParentGroup.Name, sop.ParentGroup.UUID);
continue;
}
AssignSingleMaterial(sop, face, matData);
}
}
protected string ResourceCostsSelected(string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
//m_log.DebugFormat("[ASSETCAPS] Got a ResourceCostsSelected Packet {0}.", request);
OSDMap resp = new OSDMap();
OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
float streaming_cost = 0.0f;
float simulation_cost = 0.0f;
float physics_cost = 0.0f;
// I dont see selected_prims ever sent but we cover our ass just in case
string[] tags = { "selected_roots", "selected_prims" };
foreach (string value in tags)
{
if (requestmap.ContainsKey(value) == false)
{
continue;
}
OSDArray itemsRequested = (OSDArray)requestmap[value];
foreach (OSDUUID osdItemId in itemsRequested)
{
UUID itemId = osdItemId.AsUUID();
SceneObjectPart item = m_Scene.GetSceneObjectPart(itemId);
PhysicsActor physActor;
if (item != null)
{
SceneObjectGroup parent = item.ParentGroup;
physActor = parent.RootPart.PhysActor;
if (physActor != null)
{
physics_cost += (float)physActor.TotalComplexity;
}
streaming_cost += parent.StreamingCost;
simulation_cost += parent.ServerWeight;
}
}
}
OSDMap object_data = new OSDMap();
object_data["physics"] = physics_cost;
object_data["streaming"] = streaming_cost;
object_data["simulation"] = simulation_cost;
resp["selected"] = object_data;
string response = OSDParser.SerializeLLSDXmlString(resp);
//m_log.DebugFormat("[ASSETCAPS] Sending a ResourceCostsSelected Response {0}.", response);
return(response);
}
/// <summary>
/// Add a submesh to an existing list of coords and faces.
/// </summary>
/// <param name="subMeshData"></param>
/// <param name="size">Size of entire object</param>
/// <param name="coords"></param>
/// <param name="faces"></param>
private static int DecodeMeshFace(OSDMap subMeshData)
{
// Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
// As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level
// of Detail Blocks (maps) contain just a NoGeometry key to signal there is no
// geometry for this submesh.
if (subMeshData.ContainsKey("NoGeometry") && ((OSDBoolean)subMeshData["NoGeometry"]))
{
return(0);
}
int vertex_count = 0;
if (subMeshData.ContainsKey("Position"))
{
byte[] posBytes = subMeshData["Position"].AsBinary();
vertex_count = posBytes.Length / 6;
}
return(vertex_count);
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[SPECIAL UI]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
OSDMap specialUI = new OSDMap();
using (StreamReader s = new StreamReader(Path.Combine(VIEWER_SUPPORT_DIR, "panel_toolbar.xml")))
{
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
specialUI["toolbar"] = OSDMap.FromString(s.ReadToEnd());
extrasMap["special-ui"] = specialUI;
}
m_log.DebugFormat("[SPECIAL UI]: Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
if (Directory.Exists(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters")))
{
OSDMap floaters = new OSDMap();
uint n = 0;
foreach (String name in Directory.GetFiles(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters"), "*.xml"))
{
using (StreamReader s = new StreamReader(name))
{
string simple_name = Path.GetFileNameWithoutExtension(name);
OSDMap floater = new OSDMap();
floaters[simple_name] = OSDMap.FromString(s.ReadToEnd());
n++;
}
}
specialUI["floaters"] = floaters;
m_log.DebugFormat("[SPECIAL UI]: Sending {0} floaters", n);
}
}
else
{
m_log.DebugFormat("[SPECIAL UI]: NOT Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
}
}
/// <summary>
/// Sends the mapitem response to the IClientAPI
/// </summary>
/// <param name="response">The OSDMap Response for the mapitem</param>
private void RequestMapItemsCompleted(OSDMap response)
{
UUID requestID = response["requestID"].AsUUID();
if (requestID != UUID.Zero)
{
MapRequestState mrs = new MapRequestState();
mrs.agentID = UUID.Zero;
lock (m_openRequests)
{
if (m_openRequests.ContainsKey(requestID))
{
mrs = m_openRequests[requestID];
m_openRequests.Remove(requestID);
}
}
if (mrs.agentID != UUID.Zero)
{
ScenePresence av = null;
m_scene.TryGetAvatar(mrs.agentID, out av);
if (av != null)
{
if (response.ContainsKey(mrs.itemtype.ToString()))
{
List <mapItemReply> returnitems = new List <mapItemReply>();
OSDArray itemarray = (OSDArray)response[mrs.itemtype.ToString()];
for (int i = 0; i < itemarray.Count; i++)
{
OSDMap mapitem = (OSDMap)itemarray[i];
mapItemReply mi = new mapItemReply();
mi.x = (uint)mapitem["X"].AsInteger();
mi.y = (uint)mapitem["Y"].AsInteger();
mi.id = mapitem["ID"].AsUUID();
mi.Extra = mapitem["Extra"].AsInteger();
mi.Extra2 = mapitem["Extra2"].AsInteger();
mi.name = mapitem["Name"].AsString();
returnitems.Add(mi);
}
av.ControllingClient.SendMapItemReply(returnitems.ToArray(), mrs.itemtype, mrs.flags);
}
}
}
}
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
OSD menus = new OSDMap();
if (features.ContainsKey("menus"))
menus = features["menus"];
OSDMap agent = new OSDMap();
OSDMap world = new OSDMap();
OSDMap tools = new OSDMap();
OSDMap advanced = new OSDMap();
OSDMap admin = new OSDMap();
if (((OSDMap)menus).ContainsKey("agent"))
agent = (OSDMap)((OSDMap)menus)["agent"];
if (((OSDMap)menus).ContainsKey("world"))
world = (OSDMap)((OSDMap)menus)["world"];
if (((OSDMap)menus).ContainsKey("tools"))
tools = (OSDMap)((OSDMap)menus)["tools"];
if (((OSDMap)menus).ContainsKey("advanced"))
advanced = (OSDMap)((OSDMap)menus)["advanced"];
if (((OSDMap)menus).ContainsKey("admin"))
admin = (OSDMap)((OSDMap)menus)["admin"];
if (m_menuItems.ContainsKey(UUID.Zero))
{
foreach (MenuItemData d in m_menuItems[UUID.Zero])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
continue;
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
continue;
loc[d.Title] = OSD.FromString(d.Title);
}
}
if (m_menuItems.ContainsKey(agentID))
{
foreach (MenuItemData d in m_menuItems[agentID])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
continue;
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
continue;
loc[d.Title] = OSD.FromString(d.Title);
}
}
((OSDMap)menus)["agent"] = agent;
((OSDMap)menus)["world"] = world;
((OSDMap)menus)["tools"] = tools;
((OSDMap)menus)["advanced"] = advanced;
((OSDMap)menus)["admin"] = admin;
features["menus"] = menus;
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
OSD menus = new OSDMap();
if (features.ContainsKey("menus"))
{
menus = features["menus"];
}
OSDMap agent = new OSDMap();
OSDMap world = new OSDMap();
OSDMap tools = new OSDMap();
OSDMap advanced = new OSDMap();
OSDMap admin = new OSDMap();
if (((OSDMap)menus).ContainsKey("agent"))
{
agent = (OSDMap)((OSDMap)menus)["agent"];
}
if (((OSDMap)menus).ContainsKey("world"))
{
world = (OSDMap)((OSDMap)menus)["world"];
}
if (((OSDMap)menus).ContainsKey("tools"))
{
tools = (OSDMap)((OSDMap)menus)["tools"];
}
if (((OSDMap)menus).ContainsKey("advanced"))
{
advanced = (OSDMap)((OSDMap)menus)["advanced"];
}
if (((OSDMap)menus).ContainsKey("admin"))
{
admin = (OSDMap)((OSDMap)menus)["admin"];
}
if (m_menuItems.ContainsKey(UUID.Zero))
{
foreach (MenuItemData d in m_menuItems[UUID.Zero])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
{
continue;
}
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
{
continue;
}
loc[d.Title] = OSD.FromString(d.Title);
}
}
if (m_menuItems.ContainsKey(agentID))
{
foreach (MenuItemData d in m_menuItems[agentID])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
{
continue;
}
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
{
continue;
}
loc[d.Title] = OSD.FromString(d.Title);
}
}
((OSDMap)menus)["agent"] = agent;
((OSDMap)menus)["world"] = world;
((OSDMap)menus)["tools"] = tools;
((OSDMap)menus)["advanced"] = advanced;
((OSDMap)menus)["admin"] = admin;
features["menus"] = menus;
}
/// <summary>
/// Convert raw uploaded data into the appropriate asset and item.
/// </summary>
/// <param name="assetID"></param>
/// <param name="inventoryItem"></param>
/// <param name="data"></param>
public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
string assetType)
{
m_log.DebugFormat(
"[BUNCH OF CAPS]: Uploaded asset {0} for inventory item {1}, inv type {2}, asset type {3}",
assetID, inventoryItem, inventoryType, assetType);
sbyte assType = 0;
sbyte inType = 0;
if (inventoryType == "sound")
{
inType = 1;
assType = 1;
}
else if (inventoryType == "animation")
{
inType = 19;
assType = 20;
}
else if (inventoryType == "wearable")
{
inType = 18;
switch (assetType)
{
case "bodypart":
assType = 13;
break;
case "clothing":
assType = 5;
break;
}
}
else if (inventoryType == "object")
{
inType = (sbyte)InventoryType.Object;
assType = (sbyte)AssetType.Object;
List <Vector3> positions = new List <Vector3>();
List <Quaternion> rotations = new List <Quaternion>();
OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
OSDArray instance_list = (OSDArray)request["instance_list"];
OSDArray mesh_list = (OSDArray)request["mesh_list"];
OSDArray texture_list = (OSDArray)request["texture_list"];
SceneObjectGroup grp = null;
List <UUID> textures = new List <UUID>();
for (int i = 0; i < texture_list.Count; i++)
{
AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, "");
textureAsset.Data = texture_list[i].AsBinary();
m_assetService.Store(textureAsset);
textures.Add(textureAsset.FullID);
}
for (int i = 0; i < mesh_list.Count; i++)
{
PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
Primitive.TextureEntry textureEntry
= new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
OSDMap inner_instance_list = (OSDMap)instance_list[i];
OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
for (uint face = 0; face < face_list.Count; face++)
{
OSDMap faceMap = (OSDMap)face_list[(int)face];
Primitive.TextureEntryFace f = pbs.Textures.CreateFace(face);
if (faceMap.ContainsKey("fullbright"))
{
f.Fullbright = faceMap["fullbright"].AsBoolean();
}
if (faceMap.ContainsKey("diffuse_color"))
{
f.RGBA = faceMap["diffuse_color"].AsColor4();
}
int textureNum = faceMap["image"].AsInteger();
float imagerot = faceMap["imagerot"].AsInteger();
float offsets = (float)faceMap["offsets"].AsReal();
float offsett = (float)faceMap["offsett"].AsReal();
float scales = (float)faceMap["scales"].AsReal();
float scalet = (float)faceMap["scalet"].AsReal();
if (imagerot != 0)
{
f.Rotation = imagerot;
}
if (offsets != 0)
{
f.OffsetU = offsets;
}
if (offsett != 0)
{
f.OffsetV = offsett;
}
if (scales != 0)
{
f.RepeatU = scales;
}
if (scalet != 0)
{
f.RepeatV = scalet;
}
if (textures.Count > textureNum)
{
f.TextureID = textures[textureNum];
}
else
{
f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
}
textureEntry.FaceTextures[face] = f;
}
pbs.TextureEntry = textureEntry.GetBytes();
AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, "");
meshAsset.Data = mesh_list[i].AsBinary();
m_assetService.Store(meshAsset);
pbs.SculptEntry = true;
pbs.SculptTexture = meshAsset.FullID;
pbs.SculptType = (byte)SculptType.Mesh;
pbs.SculptData = meshAsset.Data;
Vector3 position = inner_instance_list["position"].AsVector3();
Vector3 scale = inner_instance_list["scale"].AsVector3();
Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
// no longer used - begin ------------------------
// int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger();
// int material = inner_instance_list["material"].AsInteger();
// int mesh = inner_instance_list["mesh"].AsInteger();
// OSDMap permissions = (OSDMap)inner_instance_list["permissions"];
// int base_mask = permissions["base_mask"].AsInteger();
// int everyone_mask = permissions["everyone_mask"].AsInteger();
// UUID creator_id = permissions["creator_id"].AsUUID();
// UUID group_id = permissions["group_id"].AsUUID();
// int group_mask = permissions["group_mask"].AsInteger();
// bool is_owner_group = permissions["is_owner_group"].AsBoolean();
// UUID last_owner_id = permissions["last_owner_id"].AsUUID();
// int next_owner_mask = permissions["next_owner_mask"].AsInteger();
// UUID owner_id = permissions["owner_id"].AsUUID();
// int owner_mask = permissions["owner_mask"].AsInteger();
// no longer used - end ------------------------
UUID owner_id = m_HostCapsObj.AgentID;
SceneObjectPart prim
= new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);
prim.Scale = scale;
prim.OffsetPosition = position;
rotations.Add(rotation);
positions.Add(position);
prim.UUID = UUID.Random();
prim.CreatorID = owner_id;
prim.OwnerID = owner_id;
prim.GroupID = UUID.Zero;
prim.LastOwnerID = prim.OwnerID;
prim.CreationDate = Util.UnixTimeSinceEpoch();
prim.Name = assetName;
prim.Description = "";
// prim.BaseMask = (uint)base_mask;
// prim.EveryoneMask = (uint)everyone_mask;
// prim.GroupMask = (uint)group_mask;
// prim.NextOwnerMask = (uint)next_owner_mask;
// prim.OwnerMask = (uint)owner_mask;
if (grp == null)
{
grp = new SceneObjectGroup(prim);
}
else
{
grp.AddPart(prim);
}
}
// Fix first link number
if (grp.Parts.Length > 1)
{
grp.RootPart.LinkNum++;
}
Vector3 rootPos = positions[0];
grp.AbsolutePosition = rootPos;
for (int i = 0; i < positions.Count; i++)
{
Vector3 offset = positions[i] - rootPos;
grp.Parts[i].OffsetPosition = offset;
}
for (int i = 0; i < rotations.Count; i++)
{
if (i != 0)
{
grp.Parts[i].RotationOffset = rotations[i];
}
}
grp.UpdateGroupRotationR(rotations[0]);
data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
}
AssetBase asset;
asset = new AssetBase(assetID, assetName, assType, m_HostCapsObj.AgentID.ToString());
asset.Data = data;
if (AddNewAsset != null)
{
AddNewAsset(asset);
}
else if (m_assetService != null)
{
m_assetService.Store(asset);
}
InventoryItemBase item = new InventoryItemBase();
item.Owner = m_HostCapsObj.AgentID;
item.CreatorId = m_HostCapsObj.AgentID.ToString();
item.CreatorData = String.Empty;
item.ID = inventoryItem;
item.AssetID = asset.FullID;
item.Description = assetDescription;
item.Name = assetName;
item.AssetType = assType;
item.InvType = inType;
item.Folder = parentFolder;
// If we set PermissionMask.All then when we rez the item the next permissions will replace the current
// (owner) permissions. This becomes a problem if next permissions are changed.
item.CurrentPermissions
= (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
item.BasePermissions = (uint)PermissionMask.All;
item.EveryOnePermissions = 0;
item.NextPermissions = (uint)PermissionMask.All;
item.CreationDate = Util.UnixTimeSinceEpoch();
if (AddNewInventoryItem != null)
{
AddNewInventoryItem(m_HostCapsObj.AgentID, item);
}
}
// parses convex hulls component
private bool hulls(byte[] data, int offset, int size, out int nvertices, out int nhulls)
{
nvertices = 0;
nhulls = 1;
OSD decodedMeshOsd = new OSD();
byte[] meshBytes = new byte[size];
System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
try
{
using (MemoryStream inMs = new MemoryStream(meshBytes))
{
using (MemoryStream outMs = new MemoryStream())
{
using (ZOutputStream zOut = new ZOutputStream(outMs))
{
byte[] readBuffer = new byte[4096];
int readLen = 0;
while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
zOut.Write(readBuffer, 0, readLen);
}
zOut.Flush();
outMs.Seek(0, SeekOrigin.Begin);
byte[] decompressedBuf = outMs.GetBuffer();
decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
}
}
}
}
catch
{
return(false);
}
OSDMap cmap = (OSDMap)decodedMeshOsd;
if (cmap == null)
{
return(false);
}
byte[] dummy;
// must have one of this
if (cmap.ContainsKey("BoundingVerts"))
{
dummy = cmap["BoundingVerts"].AsBinary();
nvertices = dummy.Length / bytesPerCoord;
}
else
{
return(false);
}
/* upload is done with convex shape type
* if (cmap.ContainsKey("HullList"))
* {
* dummy = cmap["HullList"].AsBinary();
* nhulls += dummy.Length;
* }
*
*
* if (cmap.ContainsKey("Positions"))
* {
* dummy = cmap["Positions"].AsBinary();
* nvertices = dummy.Length / bytesPerCoord;
* }
*/
return(true);
}
private OMVSD.OSD GetHandler(RestHandler handler, Uri uri, String after)
{
OMVSD.OSDMap ret = new OMVSD.OSDMap();
string lastDate = "xx";
lock (m_chats) {
while (m_chats.Count > 0) {
ChatEntry ce = m_chats.Dequeue();
string dateString = ce.time.ToString("yyyyMMddhhmmssfff");
OMVSD.OSDMap chat = new OMVSD.OSDMap();
chat.Add("Time", new OMVSD.OSDString(dateString));
chat.Add("From", new OMVSD.OSDString(ce.fromName));
chat.Add("Message", new OMVSD.OSDString(ce.message));
chat.Add("Type", new OMVSD.OSDString(ce.chatTypeString));
chat.Add("EntryType", new OMVSD.OSDString(ChatEntryTypeString[(int)ce.chatEntryType]));
chat.Add("Position", new OMVSD.OSDString(ce.position.ToString()));
if (ce.ownerID != null) {
chat.Add("OwnerID", new OMVSD.OSDString(ce.ownerID.ToString()));
}
while (ret.ContainsKey(dateString)) {
dateString += "1";
}
ret.Add(dateString, chat);
lastDate = dateString;
}
}
return ret;
}
/// <summary>
/// Does the actual remote mapitem request
/// This should be called from an asynchronous thread
/// Request failures get blacklisted until region restart so we don't
/// continue to spend resources trying to contact regions that are down.
/// </summary>
/// <param name="httpserver">blank string, we discover this in the process</param>
/// <param name="id">Agent ID that we are making this request on behalf</param>
/// <param name="flags">passed in from packet</param>
/// <param name="EstateID">passed in from packet</param>
/// <param name="godlike">passed in from packet</param>
/// <param name="itemtype">passed in from packet</param>
/// <param name="regionhandle">Region we're looking up</param>
/// <returns></returns>
private OSDMap RequestMapItemsAsync(UUID id, uint flags,
uint EstateID, bool godlike, uint itemtype, ulong regionhandle)
{
// m_log.DebugFormat("[WORLDMAP]: RequestMapItemsAsync; region handle: {0} {1}", regionhandle, itemtype);
string httpserver = "";
bool blacklisted = false;
lock (m_blacklistedregions)
{
if (m_blacklistedregions.ContainsKey(regionhandle))
{
if (Environment.TickCount > (m_blacklistedregions[regionhandle] + blacklistTimeout))
{
m_log.DebugFormat("[WORLDMAP]: Unblock blacklisted region {0}", regionhandle);
m_blacklistedregions.Remove(regionhandle);
}
else
blacklisted = true;
}
}
if (blacklisted)
return new OSDMap();
UUID requestID = UUID.Random();
lock (m_cachedRegionMapItemsAddress)
{
if (m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
httpserver = m_cachedRegionMapItemsAddress[regionhandle];
}
if (httpserver.Length == 0)
{
uint x = 0, y = 0;
Utils.LongToUInts(regionhandle, out x, out y);
GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
if (mreg != null)
{
httpserver = mreg.ServerURI + "MAP/MapItems/" + regionhandle.ToString();
lock (m_cachedRegionMapItemsAddress)
{
if (!m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
m_cachedRegionMapItemsAddress.Add(regionhandle, httpserver);
}
}
else
{
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
//m_log.InfoFormat("[WORLD MAP]: Blacklisted region {0}", regionhandle.ToString());
}
}
blacklisted = false;
lock (m_blacklistedurls)
{
if (m_blacklistedurls.ContainsKey(httpserver))
{
if (Environment.TickCount > (m_blacklistedurls[httpserver] + blacklistTimeout))
{
m_log.DebugFormat("[WORLDMAP]: Unblock blacklisted URL {0}", httpserver);
m_blacklistedurls.Remove(httpserver);
}
else
blacklisted = true;
}
}
// Can't find the http server
if (httpserver.Length == 0 || blacklisted)
return new OSDMap();
MapRequestState mrs = new MapRequestState();
mrs.agentID = id;
mrs.EstateID = EstateID;
mrs.flags = flags;
mrs.godlike = godlike;
mrs.itemtype=itemtype;
mrs.regionhandle = regionhandle;
lock (m_openRequests)
m_openRequests.Add(requestID, mrs);
WebRequest mapitemsrequest = null;
try
{
mapitemsrequest = WebRequest.Create(httpserver);
}
catch (Exception e)
{
m_log.DebugFormat("[WORLD MAP]: Access to {0} failed with {1}", httpserver, e);
return new OSDMap();
}
mapitemsrequest.Method = "POST";
mapitemsrequest.ContentType = "application/xml+llsd";
OSDMap RAMap = new OSDMap();
// string RAMapString = RAMap.ToString();
OSD LLSDofRAMap = RAMap; // RENAME if this works
byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap);
OSDMap responseMap = new OSDMap();
responseMap["requestID"] = OSD.FromUUID(requestID);
Stream os = null;
try
{ // send the Post
mapitemsrequest.ContentLength = buffer.Length; //Count bytes to send
os = mapitemsrequest.GetRequestStream();
os.Write(buffer, 0, buffer.Length); //Send it
//m_log.DebugFormat("[WORLD MAP]: Getting MapItems from {0}", httpserver);
}
catch (WebException ex)
{
m_log.WarnFormat("[WORLD MAP]: Bad send on GetMapItems {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
finally
{
if (os != null)
os.Close();
}
string response_mapItems_reply = null;
{ // get the response
StreamReader sr = null;
try
{
WebResponse webResponse = mapitemsrequest.GetResponse();
if (webResponse != null)
{
sr = new StreamReader(webResponse.GetResponseStream());
response_mapItems_reply = sr.ReadToEnd().Trim();
}
else
{
return new OSDMap();
}
}
catch (WebException)
{
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
return responseMap;
}
finally
{
if (sr != null)
sr.Close();
}
OSD rezResponse = null;
try
{
rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply);
responseMap = (OSDMap)rezResponse;
responseMap["requestID"] = OSD.FromUUID(requestID);
}
catch (Exception ex)
{
m_log.InfoFormat("[WORLD MAP]: exception on parse of RequestMapItems reply from {0}: {1}", httpserver, ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
return responseMap;
}
}
if (!responseMap.ContainsKey(itemtype.ToString())) // remote sim doesnt have the stated region handle
{
m_log.DebugFormat("[WORLD MAP]: Remote sim does not have the stated region. Blacklisting.");
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
return responseMap;
}
/// <summary>
/// Assign The requested materials to the specified part(s).
/// </summary>
/// <param name="materialsFromViewer"></param>
private void AssignRequestedMaterials(OSDMap materialsFromViewer, UUID agentID)
{
if (!(materialsFromViewer.ContainsKey("FullMaterialsPerFace") &&
(materialsFromViewer["FullMaterialsPerFace"] is OSDArray)))
{
m_log.Warn("[RenderMaterials]: AssignRequestedMaterials - FullMaterialsPerFace not defined or incorrect type");
return;
}
OSDArray mats = materialsFromViewer["FullMaterialsPerFace"] as OSDArray;
foreach (OSDMap matsMap in mats)
{
uint matLocalID = 0;
int face = -1;
OSDMap matData = null;
try
{
matLocalID = matsMap["ID"].AsUInteger();
if (matsMap.ContainsKey("Face"))
face = matsMap["Face"].AsInteger();
if (matsMap.ContainsKey("Material"))
matData = matsMap["Material"] as OSDMap;
}
catch (Exception e)
{
m_log.Warn("[RenderMaterials]: cannot decode material from matsMap: " + e.Message);
continue;
}
/// Look up the scene object this material pertains to.
var sop = m_scene.GetSceneObjectPart(matLocalID);
if (sop == null)
{
m_log.Warn("[RenderMaterials]: null SOP for localId: " + matLocalID.ToString());
continue;
}
// Make sure we can modify it
if (m_scene.Permissions.CanEditObject(sop.UUID, agentID, (uint)PermissionMask.Modify) == false)
{
m_log.WarnFormat("[RenderMaterials]: User {0} can't edit object {1} {2}", agentID, sop.Name, sop.UUID);
continue;
}
AssignSingleMaterial(sop, face, matData);
}
}
// parses convex hulls component
private bool hulls(byte[] data, int offset, int size, out int nvertices, out int nhulls)
{
nvertices = 0;
nhulls = 1;
OSD decodedMeshOsd = new OSD();
try
{
using (MemoryStream outMs = new MemoryStream(4 * size))
{
using (MemoryStream inMs = new MemoryStream(data, offset, size))
{
using (DeflateStream decompressionStream = new DeflateStream(inMs, CompressionMode.Decompress))
{
byte[] readBuffer = new byte[8192];
inMs.Read(readBuffer, 0, 2); // skip first 2 bytes in header
int readLen = 0;
while ((readLen = decompressionStream.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
outMs.Write(readBuffer, 0, readLen);
}
}
}
outMs.Seek(0, SeekOrigin.Begin);
decodedMeshOsd = OSDParser.DeserializeLLSDBinary(outMs);
}
}
catch
{
return(false);
}
OSDMap cmap = (OSDMap)decodedMeshOsd;
if (cmap == null)
{
return(false);
}
byte[] dummy;
// must have one of this
if (cmap.ContainsKey("BoundingVerts"))
{
dummy = cmap["BoundingVerts"].AsBinary();
nvertices = dummy.Length / bytesPerCoord;
}
else
{
return(false);
}
/* upload is done with convex shape type
* if (cmap.ContainsKey("HullList"))
* {
* dummy = cmap["HullList"].AsBinary();
* nhulls += dummy.Length;
* }
*
*
* if (cmap.ContainsKey("Positions"))
* {
* dummy = cmap["Positions"].AsBinary();
* nvertices = dummy.Length / bytesPerCoord;
* }
*/
return(true);
}
// updates and returns true if the value changed
private bool InternalUpdate(string key, OMVSD.OSD value)
{
bool ret = false;
lock (m_params) {
if (m_params.ContainsKey(key.ToLower()))
{
m_params[key.ToLower()] = value;
ret = true;
}
}
return(ret);
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
// Detaching attachments doesn't work for HG visitors,
// so I'm giving that up.
//Util.FireAndForget(delegate { DetachAttachments(agentID); });
}
else
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
private void SetExtEnvironmentSettings(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID, Caps caps)
{
bool success = false;
string message = "Could not process request";
int parcel = -1;
int track = -1;
StringBuilder sb = LLSDxmlEncode.Start();
ScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null || sp.IsChildAgent || sp.IsNPC)
{
message = "Could not locate your avatar";
goto Error;
}
if (httpRequest.Query.Count > 0)
{
if (httpRequest.Query.ContainsKey("parcelid"))
{
if (!Int32.TryParse((string)httpRequest.Query["parcelid"], out parcel))
{
message = "Failed to decode request";
goto Error;
}
}
if (httpRequest.Query.ContainsKey("trackno"))
{
if (!Int32.TryParse((string)httpRequest.Query["trackno"], out track))
{
message = "Failed to decode request";
goto Error;
}
}
if (track != -1)
{
message = "Environment Track not supported";
goto Error;
}
}
ViewerEnvironment VEnv = m_scene.RegionEnvironment;
ILandObject lchannel;
if (parcel == -1)
{
if (!m_scene.Permissions.CanIssueEstateCommand(agentID, false))
{
message = "Insufficient estate permissions, settings has not been saved.";
goto Error;
}
VEnv = m_scene.RegionEnvironment;
lchannel = null;
}
else
{
lchannel = m_landChannel.GetLandObject(parcel);
if (lchannel == null || lchannel.LandData == null)
{
message = "Could not locate requested parcel";
goto Error;
}
if (!m_scene.Permissions.CanEditParcelProperties(agentID, lchannel, (GroupPowers.AllowEnvironment | GroupPowers.LandEdit), true)) // wrong
{
message = "No permission to change parcel environment";
goto Error;
}
VEnv = lchannel.LandData.Environment;
}
try
{
OSD req = OSDParser.Deserialize(httpRequest.InputStream);
if (req is OpenMetaverse.StructuredData.OSDMap)
{
OSDMap map = req as OpenMetaverse.StructuredData.OSDMap;
if (map.TryGetValue("environment", out OSD env))
{
if (VEnv == null)
{
// need a proper clone
VEnv = m_DefaultEnv.Clone();
}
OSDMap evmap = (OSDMap)env;
if (evmap.TryGetValue("day_asset", out OSD tmp) && !evmap.ContainsKey("day_cycle"))
{
string id = tmp.AsString();
AssetBase asset = m_assetService.Get(id);
if (asset == null || asset.Data == null || asset.Data.Length == 0)
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
try
{
OSD oenv = OSDParser.Deserialize(asset.Data);
VEnv.CycleFromOSD(oenv);
}
catch
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
VEnv.FromOSD(env);
if (lchannel == null)
{
StoreOnRegion(VEnv);
m_log.InfoFormat("[{0}]: ExtEnvironment region {1} settings from agentID {2} saved",
Name, caps.RegionName, agentID);
}
else
{
lchannel.StoreEnvironment(VEnv);
m_log.InfoFormat("[{0}]: ExtEnvironment parcel {1} of region {2} settings from agentID {3} saved",
Name, parcel, caps.RegionName, agentID);
}
WindlightRefresh(0, lchannel == null);
success = true;
}
}
else if (req is OSDArray)
{
VEnv = new ViewerEnvironment();
VEnv.FromWLOSD(req);
StoreOnRegion(VEnv);
success = true;
WindlightRefresh(0);
m_log.InfoFormat("[{0}]: ExtEnvironment region {1} settings from agentID {2} saved",
Name, caps.RegionName, agentID);
LLSDxmlEncode.AddMap(sb);
LLSDxmlEncode.AddElem("messageID", UUID.Zero, sb);
LLSDxmlEncode.AddElem("regionID", regionID, sb);
LLSDxmlEncode.AddElem("success", success, sb);
LLSDxmlEncode.AddEndMap(sb);
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDxmlEncode.End(sb));
httpResponse.StatusCode = (int)HttpStatusCode.OK;
return;
}
}
catch (Exception e)
{
m_log.ErrorFormat("[{0}]: ExtEnvironment settings not saved for region {1}, Exception: {2} - {3}",
Name, caps.RegionName, e.Message, e.StackTrace);
success = false;
message = String.Format("ExtEnvironment Set for region {0} has failed, settings not saved.", caps.RegionName);
}
Error:
string response;
LLSDxmlEncode.AddMap(sb);
LLSDxmlEncode.AddElem("success", success, sb);
if (!success)
{
LLSDxmlEncode.AddElem("message", message, sb);
}
LLSDxmlEncode.AddEndMap(sb);
response = LLSDxmlEncode.End(sb);
httpResponse.RawBuffer = Util.UTF8NBGetbytes(response);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
}
// parses a LOD or physics mesh component
private bool submesh(byte[] data, int offset, int size, out int ntriangles, out int nsides)
{
ntriangles = 0;
nsides = 0;
OSD decodedMeshOsd = new OSD();
try
{
using (MemoryStream outMs = new MemoryStream())
{
using (MemoryStream inMs = new MemoryStream(data, offset, size))
{
using (DeflateStream decompressionStream = new DeflateStream(inMs, CompressionMode.Decompress))
{
byte[] readBuffer = new byte[2048];
inMs.Read(readBuffer, 0, 2); // skip first 2 bytes in header
int readLen = 0;
while ((readLen = decompressionStream.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
outMs.Write(readBuffer, 0, readLen);
}
}
}
outMs.Seek(0, SeekOrigin.Begin);
decodedMeshOsd = OSDParser.DeserializeLLSDBinary(outMs);
}
}
catch
{
return(false);
}
OSDArray decodedMeshOsdArray = null;
byte[] dummy;
decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
foreach (OSD subMeshOsd in decodedMeshOsdArray)
{
if (subMeshOsd is OSDMap)
{
OSDMap subtmpmap = (OSDMap)subMeshOsd;
if (subtmpmap.ContainsKey("NoGeometry") && ((OSDBoolean)subtmpmap["NoGeometry"]))
{
continue;
}
if (!subtmpmap.ContainsKey("Position"))
{
return(false);
}
if (subtmpmap.ContainsKey("TriangleList"))
{
dummy = subtmpmap["TriangleList"].AsBinary();
ntriangles += dummy.Length / bytesPerCoord;
}
else
{
return(false);
}
nsides++;
}
}
return(true);
}
// single mesh asset cost
private bool MeshCost(byte[] data, ameshCostParam cost, out bool skeleton, out bool avatarPhys, out string error)
{
cost.highLODSize = 0;
cost.medLODSize = 0;
cost.lowLODSize = 0;
cost.lowestLODSize = 0;
cost.physicsCost = 0.0f;
cost.costFee = 0.0f;
error = string.Empty;
skeleton = false;
avatarPhys = false;
if (data == null || data.Length == 0)
{
error = "Missing model information.";
return(false);
}
OSD meshOsd = null;
int start = 0;
error = "Invalid model data";
using (MemoryStream ms = new MemoryStream(data))
{
try
{
OSD osd = OSDParser.DeserializeLLSDBinary(ms);
if (osd is OSDMap)
{
meshOsd = (OSDMap)osd;
}
else
{
return(false);
}
}
catch
{
return(false);
}
start = (int)ms.Position;
}
OSDMap map = (OSDMap)meshOsd;
OSDMap tmpmap;
int highlod_size = 0;
int medlod_size = 0;
int lowlod_size = 0;
int lowestlod_size = 0;
int skin_size = 0;
int hulls_size = 0;
int phys_nhulls;
int phys_hullsvertices = 0;
int physmesh_size = 0;
int phys_ntriangles = 0;
int submesh_offset = -1;
if (map.ContainsKey("skeleton"))
{
tmpmap = (OSDMap)map["skeleton"];
if (tmpmap.ContainsKey("offset") && tmpmap.ContainsKey("size"))
{
int sksize = tmpmap["size"].AsInteger();
if (sksize > 0)
{
skeleton = true;
}
}
}
if (map.ContainsKey("physics_convex"))
{
tmpmap = (OSDMap)map["physics_convex"];
if (tmpmap.ContainsKey("offset"))
{
submesh_offset = tmpmap["offset"].AsInteger() + start;
}
if (tmpmap.ContainsKey("size"))
{
hulls_size = tmpmap["size"].AsInteger();
}
}
if (submesh_offset < 0 || hulls_size == 0)
{
error = "Missing physics_convex block";
return(false);
}
if (!hulls(data, submesh_offset, hulls_size, out phys_hullsvertices, out phys_nhulls))
{
error = "Bad physics_convex block";
return(false);
}
submesh_offset = -1;
// only look for LOD meshs sizes
if (map.ContainsKey("high_lod"))
{
tmpmap = (OSDMap)map["high_lod"];
// see at least if there is a offset for this one
if (tmpmap.ContainsKey("offset"))
{
submesh_offset = tmpmap["offset"].AsInteger() + start;
}
if (tmpmap.ContainsKey("size"))
{
highlod_size = tmpmap["size"].AsInteger();
}
}
if (submesh_offset < 0 || highlod_size <= 0)
{
error = "Missing high_lod block";
return(false);
}
bool haveprev = true;
if (map.ContainsKey("medium_lod"))
{
tmpmap = (OSDMap)map["medium_lod"];
if (tmpmap.ContainsKey("size"))
{
medlod_size = tmpmap["size"].AsInteger();
}
else
{
haveprev = false;
}
}
if (haveprev && map.ContainsKey("low_lod"))
{
tmpmap = (OSDMap)map["low_lod"];
if (tmpmap.ContainsKey("size"))
{
lowlod_size = tmpmap["size"].AsInteger();
}
else
{
haveprev = false;
}
}
if (haveprev && map.ContainsKey("lowest_lod"))
{
tmpmap = (OSDMap)map["lowest_lod"];
if (tmpmap.ContainsKey("size"))
{
lowestlod_size = tmpmap["size"].AsInteger();
}
}
if (map.ContainsKey("skin"))
{
tmpmap = (OSDMap)map["skin"];
if (tmpmap.ContainsKey("size"))
{
skin_size = tmpmap["size"].AsInteger();
}
}
cost.highLODSize = highlod_size;
cost.medLODSize = medlod_size;
cost.lowLODSize = lowlod_size;
cost.lowestLODSize = lowestlod_size;
submesh_offset = -1;
tmpmap = null;
if (map.ContainsKey("physics_mesh"))
{
tmpmap = (OSDMap)map["physics_mesh"];
}
else if (map.ContainsKey("physics_shape")) // old naming
{
tmpmap = (OSDMap)map["physics_shape"];
}
if (tmpmap != null)
{
if (tmpmap.ContainsKey("offset"))
{
submesh_offset = tmpmap["offset"].AsInteger() + start;
}
if (tmpmap.ContainsKey("size"))
{
physmesh_size = tmpmap["size"].AsInteger();
}
if (submesh_offset >= 0 || physmesh_size > 0)
{
if (!submesh(data, submesh_offset, physmesh_size, out phys_ntriangles))
{
error = "Model data parsing error";
return(false);
}
}
}
// upload is done in convex shape type so only one hull
phys_hullsvertices++;
cost.physicsCost = 0.04f * phys_hullsvertices;
float sfee;
sfee = data.Length; // start with total compressed data size
// penalize lod meshs that should be more builder optimized
sfee += medSizeWth * medlod_size;
sfee += lowSizeWth * lowlod_size;
sfee += lowestSizeWth * lowlod_size;
// physics
// favor potencial optimized meshs versus automatic decomposition
if (physmesh_size != 0)
{
sfee += physMeshSizeWth * (physmesh_size + hulls_size / 4); // reduce cost of mandatory convex hull
}
else
{
sfee += physHullSizeWth * hulls_size;
}
// bytes to money
sfee *= bytecost;
cost.costFee = sfee;
return(true);
}
// parses a LOD or physics mesh component
private bool submesh(byte[] data, int offset, int size, out int ntriangles)
{
ntriangles = 0;
OSD decodedMeshOsd = new OSD();
byte[] meshBytes = new byte[size];
System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
try
{
using (MemoryStream inMs = new MemoryStream(meshBytes))
{
using (MemoryStream outMs = new MemoryStream())
{
using (ZOutputStream zOut = new ZOutputStream(outMs))
{
byte[] readBuffer = new byte[4096];
int readLen = 0;
while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
zOut.Write(readBuffer, 0, readLen);
}
zOut.Flush();
outMs.Seek(0, SeekOrigin.Begin);
byte[] decompressedBuf = outMs.GetBuffer();
decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
}
}
}
}
catch
{
return(false);
}
OSDArray decodedMeshOsdArray = null;
byte[] dummy;
decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
foreach (OSD subMeshOsd in decodedMeshOsdArray)
{
if (subMeshOsd is OSDMap)
{
OSDMap subtmpmap = (OSDMap)subMeshOsd;
if (subtmpmap.ContainsKey("NoGeometry") && ((OSDBoolean)subtmpmap["NoGeometry"]))
{
continue;
}
if (!subtmpmap.ContainsKey("Position"))
{
return(false);
}
if (subtmpmap.ContainsKey("TriangleList"))
{
dummy = subtmpmap["TriangleList"].AsBinary();
ntriangles += dummy.Length / bytesPerCoord;
}
else
{
return(false);
}
}
}
return(true);
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[SPECIAL UI]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
OSDMap specialUI = new OSDMap();
using (StreamReader s = new StreamReader(Path.Combine(VIEWER_SUPPORT_DIR, "panel_toolbar.xml")))
{
if (features.ContainsKey("OpenSimExtras"))
extrasMap = (OSDMap)features["OpenSimExtras"];
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
specialUI["toolbar"] = OSDMap.FromString(s.ReadToEnd());
extrasMap["special-ui"] = specialUI;
}
m_log.DebugFormat("[SPECIAL UI]: Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
if (Directory.Exists(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters")))
{
OSDMap floaters = new OSDMap();
uint n = 0;
foreach (String name in Directory.GetFiles(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters"), "*.xml"))
{
using (StreamReader s = new StreamReader(name))
{
string simple_name = Path.GetFileNameWithoutExtension(name);
OSDMap floater = new OSDMap();
floaters[simple_name] = OSDMap.FromString(s.ReadToEnd());
n++;
}
}
specialUI["floaters"] = floaters;
m_log.DebugFormat("[SPECIAL UI]: Sending {0} floaters", n);
}
}
else
m_log.DebugFormat("[SPECIAL UI]: NOT Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
}
/// <summary>
/// Sends the mapitem response to the IClientAPI
/// </summary>
/// <param name="response">The OSDMap Response for the mapitem</param>
private void RequestMapItemsCompleted(OSDMap response)
{
UUID requestID = response["requestID"].AsUUID();
if (requestID != UUID.Zero)
{
MapRequestState mrs = new MapRequestState();
mrs.agentID = UUID.Zero;
lock (m_openRequests)
{
if (m_openRequests.ContainsKey(requestID))
{
mrs = m_openRequests[requestID];
m_openRequests.Remove(requestID);
}
}
if (mrs.agentID != UUID.Zero)
{
ScenePresence av = null;
m_scene.TryGetScenePresence(mrs.agentID, out av);
if (av != null)
{
if (response.ContainsKey(mrs.itemtype.ToString()))
{
List<mapItemReply> returnitems = new List<mapItemReply>();
OSDArray itemarray = (OSDArray)response[mrs.itemtype.ToString()];
for (int i = 0; i < itemarray.Count; i++)
{
OSDMap mapitem = (OSDMap)itemarray[i];
mapItemReply mi = new mapItemReply();
mi.x = (uint)mapitem["X"].AsInteger();
mi.y = (uint)mapitem["Y"].AsInteger();
mi.id = mapitem["ID"].AsUUID();
mi.Extra = mapitem["Extra"].AsInteger();
mi.Extra2 = mapitem["Extra2"].AsInteger();
mi.name = mapitem["Name"].AsString();
returnitems.Add(mi);
}
av.ControllingClient.SendMapItemReply(returnitems.ToArray(), mrs.itemtype, mrs.flags);
}
}
}
}
}
/// <summary>
/// Does the actual remote mapitem request
/// This should be called from an asynchronous thread
/// Request failures get blacklisted until region restart so we don't
/// continue to spend resources trying to contact regions that are down.
/// </summary>
/// <param name="httpserver">blank string, we discover this in the process</param>
/// <param name="id">Agent ID that we are making this request on behalf</param>
/// <param name="flags">passed in from packet</param>
/// <param name="EstateID">passed in from packet</param>
/// <param name="godlike">passed in from packet</param>
/// <param name="itemtype">passed in from packet</param>
/// <param name="regionhandle">Region we're looking up</param>
/// <returns></returns>
private OSDMap RequestMapItemsAsync(UUID id, uint flags,
uint EstateID, bool godlike, uint itemtype, ulong regionhandle)
{
string httpserver = "";
bool blacklisted = false;
lock (m_blacklistedregions)
{
if (m_blacklistedregions.ContainsKey(regionhandle))
{
blacklisted = true;
}
}
if (blacklisted)
{
return(new OSDMap());
}
UUID requestID = UUID.Random();
lock (m_cachedRegionMapItemsAddress)
{
if (m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
{
httpserver = m_cachedRegionMapItemsAddress[regionhandle];
}
}
if (httpserver.Length == 0)
{
uint x = 0, y = 0;
Utils.LongToUInts(regionhandle, out x, out y);
GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
if (mreg != null)
{
httpserver = mreg.ServerURI + "MAP/MapItems/" + regionhandle.ToString();
lock (m_cachedRegionMapItemsAddress)
{
if (!m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
{
m_cachedRegionMapItemsAddress.Add(regionhandle, httpserver);
}
}
}
else
{
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
{
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
//m_log.InfoFormat("[WORLD MAP]: Blacklisted region {0}", regionhandle.ToString());
}
}
blacklisted = false;
lock (m_blacklistedurls)
{
if (m_blacklistedurls.ContainsKey(httpserver))
{
blacklisted = true;
}
}
// Can't find the http server
if (httpserver.Length == 0 || blacklisted)
{
return(new OSDMap());
}
MapRequestState mrs = new MapRequestState();
mrs.agentID = id;
mrs.EstateID = EstateID;
mrs.flags = flags;
mrs.godlike = godlike;
mrs.itemtype = itemtype;
mrs.regionhandle = regionhandle;
lock (m_openRequests)
m_openRequests.Add(requestID, mrs);
WebRequest mapitemsrequest = null;
try
{
mapitemsrequest = WebRequest.Create(httpserver);
}
catch (Exception e)
{
m_log.DebugFormat("[WORLD MAP]: Access to {0} failed with {1}", httpserver, e);
return(new OSDMap());
}
mapitemsrequest.Method = "POST";
mapitemsrequest.ContentType = "application/xml+llsd";
OSDMap RAMap = new OSDMap();
// string RAMapString = RAMap.ToString();
OSD LLSDofRAMap = RAMap; // RENAME if this works
byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap);
OSDMap responseMap = new OSDMap();
responseMap["requestID"] = OSD.FromUUID(requestID);
Stream os = null;
try
{ // send the Post
mapitemsrequest.ContentLength = buffer.Length; //Count bytes to send
os = mapitemsrequest.GetRequestStream();
os.Write(buffer, 0, buffer.Length); //Send it
os.Close();
//m_log.DebugFormat("[WORLD MAP]: Getting MapItems from {0}", httpserver);
}
catch (WebException ex)
{
m_log.WarnFormat("[WORLD MAP]: Bad send on GetMapItems {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
{
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return(responseMap);
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
return(responseMap);
}
string response_mapItems_reply = null;
{ // get the response
StreamReader sr = null;
try
{
WebResponse webResponse = mapitemsrequest.GetResponse();
if (webResponse != null)
{
sr = new StreamReader(webResponse.GetResponseStream());
response_mapItems_reply = sr.ReadToEnd().Trim();
}
else
{
return(new OSDMap());
}
}
catch (WebException)
{
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
{
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return(responseMap);
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
{
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
return(responseMap);
}
finally
{
if (sr != null)
{
sr.Close();
}
}
OSD rezResponse = null;
try
{
rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply);
responseMap = (OSDMap)rezResponse;
responseMap["requestID"] = OSD.FromUUID(requestID);
}
catch (Exception ex)
{
m_log.InfoFormat("[WORLD MAP]: exception on parse of RequestMapItems reply from {0}: {1}", httpserver, ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
{
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
return(responseMap);
}
}
if (!responseMap.ContainsKey(itemtype.ToString())) // remote sim doesnt have the stated region handle
{
m_log.DebugFormat("[WORLD MAP]: Remote sim does not have the stated region. Blacklisting.");
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
{
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
}
return(responseMap);
}
/// <summary>
/// Add a submesh to an existing list of coords and faces.
/// </summary>
/// <param name="subMeshData"></param>
/// <param name="size">Size of entire object</param>
/// <param name="coords"></param>
/// <param name="faces"></param>
private static int DecodeMeshFace(OSDMap subMeshData)
{
// Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
// As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level
// of Detail Blocks (maps) contain just a NoGeometry key to signal there is no
// geometry for this submesh.
if (subMeshData.ContainsKey("NoGeometry") && ((OSDBoolean)subMeshData["NoGeometry"]))
return 0;
int vertex_count = 0;
if (subMeshData.ContainsKey("Position"))
{
byte[] posBytes = subMeshData["Position"].AsBinary();
vertex_count = posBytes.Length / 6;
}
return vertex_count;
}
