private void NewFileAgentInventoryHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryMessage>(request.Body, out message))
{
m_log.Error("Implement NewFileAgentInventory");
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventory");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void ParcelVoiceInfoRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ParcelVoiceInfoRequestMessage message;
if (LLUtil.TryGetMessage <ParcelVoiceInfoRequestMessage>(request.Body, out message))
{
m_log.DebugFormat("ParcelVoiceInfoRequest: RegionName={0}, ParcelID={1}, SipChannelUri={2}",
message.RegionName, message.ParcelID, message.SipChannelUri);
}
else
{
m_log.Warn("Received invalid request data for ParcelVoiceInfoRequest");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void NewFileAgentInventoryVariablePriceHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryVariablePriceMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryVariablePriceMessage>(request.Body, out message))
{
NewFileAgentInventoryVariablePriceReplyMessage reply = new NewFileAgentInventoryVariablePriceReplyMessage();
reply.ResourceCost = 0;
reply.UploadPrice = 0;
// Create a one time upload capability
reply.Rsvp = m_scene.Capabilities.AddOneTimeCapability(cap.OwnerID, true,
delegate(Capability _cap, IHttpClientContext _context, IHttpRequest _request, IHttpResponse _response)
{ NewFileAgentInventoryVariablePriceUploadHandler(message, _cap, _context, _request, _response); }
);
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventoryVariablePrice");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void UploadObjectAssetHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
UploadObjectAssetMessage message;
if (LLUtil.TryGetMessage <UploadObjectAssetMessage>(request.Body, out message))
{
LLPrimitive parent = null;
// Build the linkset
for (int i = 0; i < message.Objects.Length; i++)
{
UploadObjectAssetMessage.Object obj = message.Objects[i];
#region Primitive Creation
Primitive prim = new Primitive();
prim.Properties = new Primitive.ObjectProperties();
prim.Sculpt = new Primitive.SculptData();
prim.Textures = new Primitive.TextureEntry(UUID.Zero);
prim.Flags = PrimFlags.CastShadows | PrimFlags.InventoryEmpty | PrimFlags.CreateSelected;
prim.ID = UUID.Random();
prim.MediaURL = String.Empty;
prim.OwnerID = cap.OwnerID;
prim.GroupID = obj.GroupID;
prim.TextColor = Color4.Black;
prim.Properties.CreationDate = DateTime.UtcNow;
prim.Properties.CreatorID = cap.OwnerID;
prim.Properties.Description = String.Empty;
prim.Properties.GroupID = obj.GroupID;
prim.Properties.LastOwnerID = cap.OwnerID;
prim.Properties.Name = obj.Name;
prim.Properties.ObjectID = prim.ID;
prim.Properties.OwnerID = prim.OwnerID;
prim.Properties.Permissions = (m_permissions != null) ?
m_permissions.GetDefaultPermissions() :
Permissions.FullPermissions;
prim.Properties.SalePrice = 10;
prim.PrimData.PCode = PCode.Prim;
prim.PrimData.Material = obj.Material;
prim.PrimData.PathBegin = obj.PathBegin;
prim.PrimData.PathCurve = (PathCurve)obj.PathCurve;
prim.PrimData.PathEnd = obj.PathEnd;
prim.PrimData.ProfileBegin = obj.ProfileBegin;
prim.PrimData.ProfileCurve = (ProfileCurve)obj.ProfileCurve;
prim.PrimData.ProfileEnd = obj.ProfileEnd;
prim.PrimData.ProfileHollow = obj.ProfileHollow;
prim.PrimData.PathRadiusOffset = obj.RadiusOffset;
prim.PrimData.PathRevolutions = obj.Revolutions;
prim.PrimData.PathScaleX = obj.ScaleX;
prim.PrimData.PathScaleY = obj.ScaleY;
prim.PrimData.PathShearX = obj.ShearX;
prim.PrimData.PathShearY = obj.ShearY;
prim.PrimData.PathSkew = obj.Skew;
prim.PrimData.PathTaperX = obj.TaperX;
prim.PrimData.PathTaperY = obj.TaperY;
prim.PrimData.PathTwist = obj.Twist;
prim.PrimData.PathTwistBegin = obj.TwistBegin;
// Extra parameters
for (int j = 0; j < obj.ExtraParams.Length; j++)
{
UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[j];
switch (extraParam.Type)
{
case ExtraParamType.Flexible:
prim.Flexible = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Light:
prim.Light = new Primitive.LightData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Sculpt:
prim.Sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
break;
}
}
// Faces
for (int j = 0; j < obj.Faces.Length; j++)
{
UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
Primitive.TextureEntryFace primFace = prim.Textures.GetFace(0);
primFace.Bump = face.Bump;
primFace.RGBA = face.Color;
primFace.Fullbright = face.Fullbright;
primFace.Glow = face.Glow;
primFace.TextureID = face.ImageID;
primFace.Rotation = face.ImageRot;
primFace.MediaFlags = ((face.MediaFlags & MEDIA_MASK) != 0);
primFace.OffsetU = face.OffsetS;
primFace.OffsetV = face.OffsetT;
primFace.RepeatU = face.ScaleS;
primFace.RepeatV = face.ScaleT;
primFace.TexMapType = (MappingType)(face.MediaFlags & TEX_MAP_MASK);
}
prim.Sculpt.SculptTexture = obj.SculptID;
prim.Sculpt.Type = obj.SculptType;
#endregion Primitive Creation
LLPrimitive llprim = new LLPrimitive(prim, m_scene, m_primMesher);
llprim.Scale = obj.Scale;
// Link children prims to the parent
if (i == 0)
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
parent = llprim;
}
else
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
llprim.SetParent(parent, true, false);
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
}
}
}
else
{
m_log.Warn("Received invalid data for UploadObjectAsset");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void ViewerStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ViewerStatsMessage message;
if (LLUtil.TryGetMessage <ViewerStatsMessage>(request.Body, out message))
{
DateTime timestamp = DateTime.UtcNow;
if (m_statsTracker != null)
{
// Log timestamped data points
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentFPS", message.AgentFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentMemoryUsed", message.AgentMemoryUsed);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentPing", message.AgentPing);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentsInView", message.AgentsInView);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresInvalid", message.FailuresInvalid);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresOffCircuit", message.FailuresOffCircuit);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresResent", message.FailuresResent);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresSendPacket", message.FailuresSendPacket);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InCompressedPackets", message.InCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InKbytes", message.InKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InPackets", message.InPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InSavings", message.InSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MetersTraveled", message.MetersTraveled);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt1", message.MiscInt1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt2", message.MiscInt2);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscString1", message.MiscString1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscVersion", message.MiscVersion);
m_statsTracker.LogEntry(timestamp, message.SessionID, "ObjectKbytes", message.object_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutCompressedPackets", message.OutCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutKbytes", message.OutKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutPackets", message.OutPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutSavings", message.OutSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "RegionsVisisted", message.RegionsVisited);
m_statsTracker.LogEntry(timestamp, message.SessionID, "SimulatorFPS", message.SimulatorFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsDropped", message.StatsDropped);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsFailedResends", message.StatsFailedResends);
m_statsTracker.LogEntry(timestamp, message.SessionID, "TextureKbytes", message.texture_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "WorldKbytes", message.world_kbytes);
// Update constant values for this session
m_statsTracker.SetValue(message.SessionID, "AgentLanguage", message.AgentLanguage);
m_statsTracker.SetValue(message.SessionID, "AgentRuntime", message.AgentRuntime);
m_statsTracker.SetValue(message.SessionID, "AgentStartTime", message.AgentStartTime);
m_statsTracker.SetValue(message.SessionID, "AgentVersion", message.AgentVersion);
m_statsTracker.SetValue(message.SessionID, "SystemCPU", message.SystemCPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPU", message.SystemGPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPUClass", message.SystemGPUClass);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVendor", message.SystemGPUVendor);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVersion", message.SystemGPUVersion);
m_statsTracker.SetValue(message.SessionID, "SystemInstalledRam", message.SystemInstalledRam);
m_statsTracker.SetValue(message.SessionID, "SystemOS", message.SystemOS);
m_statsTracker.SetValue(message.SessionID, "VertexBuffersEnabled", message.VertexBuffersEnabled);
}
}
else
{
m_log.Warn("Received invalid data for ViewerStats");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void ObjectMediaHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ObjectMediaMessage message;
if (LLUtil.TryGetMessage <ObjectMediaMessage>(request.Body, out message))
{
if (message.Request is ObjectMediaRequest)
{
ObjectMediaRequest mediaRequest = (ObjectMediaRequest)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(mediaRequest.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
ObjectMediaResponse reply = new ObjectMediaResponse();
reply.PrimID = prim.ID;
reply.FaceMedia = prim.Prim.FaceMedia ?? new MediaEntry[0];
reply.Version = prim.Prim.MediaVersion ?? String.Empty;
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received an ObjectMedia request for unknown prim " + mediaRequest.PrimID);
}
}
else if (message.Request is ObjectMediaUpdate)
{
ObjectMediaUpdate update = (ObjectMediaUpdate)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(update.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
int lastVersion = ParseMediaVersion(prim.Prim.MediaVersion);
prim.Prim.FaceMedia = update.FaceMedia;
prim.Prim.MediaVersion = CreateMediaVersion(lastVersion + 1, cap.OwnerID);
// Set the CurrentURL fields
for (int i = 0; i < prim.Prim.FaceMedia.Length; i++)
{
MediaEntry entry = prim.Prim.FaceMedia[i];
if (entry != null && String.IsNullOrEmpty(entry.CurrentURL))
{
entry.CurrentURL = entry.HomeURL;
}
}
// Set the texture face media flags
for (int i = 0; i < prim.Prim.Textures.FaceTextures.Length; i++)
{
Primitive.TextureEntryFace face = prim.Prim.Textures.FaceTextures[i];
MediaEntry entry = (update.FaceMedia.Length > i) ? update.FaceMedia[i] : null;
if (entry != null)
{
if (face == null)
{
face = prim.Prim.Textures.CreateFace((uint)i);
}
face.MediaFlags = true;
}
else if (face != null)
{
face.MediaFlags = false;
}
}
m_scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0);
}
else
{
m_log.Warn("Could not update ObjectMedia for " + update.PrimID + ", prim not found");
}
}
else
{
m_log.Warn("Unrecognized ObjectMedia message: " + message.Request);
}
}
else
{
m_log.Warn("Received invalid data for ObjectMedia");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
