/// <summary>
/// </summary>
/// <param name="assetName"></param>
/// <param name="assetDescription"></param>
/// <param name="assetID"></param>
/// <param name="inventoryItem"></param>
/// <param name="parentFolder"></param>
/// <param name="data"></param>
/// <param name="inventoryType"></param>
/// <param name="assetType"></param>
/// <param name="everyoneMask"></param>
/// <param name="groupMask"></param>
/// <param name="nextOwnerMask"></param>
public UUID UploadCompleteHandler (string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte [] data, string inventoryType,
string assetType, uint everyoneMask, uint groupMask, uint nextOwnerMask)
{
sbyte assType = 0;
sbyte inType = 0;
switch (inventoryType) {
case "sound":
inType = 1;
assType = 1;
break;
case "animation":
inType = 19;
assType = 20;
break;
case "snapshot":
inType = 15;
assType = 0;
break;
case "wearable":
inType = 18;
switch (assetType) {
case "bodypart":
assType = 13;
break;
case "clothing":
assType = 5;
break;
}
break;
case "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> ();
foreach (
AssetBase textureAsset in
texture_list.Select (t => new AssetBase (UUID.Random (), assetName, AssetType.Texture,
m_agentID) { Data = t.AsBinary () })) {
textureAsset.ID = m_assetService.Store (textureAsset);
textures.Add (textureAsset.ID);
}
InventoryFolderBase meshFolder = m_inventoryService.GetFolderForType (m_agentID, InventoryType.Mesh, FolderType.Mesh);
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;
f.TextureID = textures.Count > textureNum
? textures [textureNum]
: Primitive.TextureEntry.WHITE_TEXTURE;
textureEntry.FaceTextures [face] = f;
}
pbs.TextureEntry = textureEntry.GetBytes ();
AssetBase meshAsset = new AssetBase (UUID.Random (), assetName, AssetType.Mesh, m_agentID) { Data = mesh_list [i].AsBinary () };
meshAsset.ID = m_assetService.Store (meshAsset);
if (meshFolder == null) {
m_inventoryService.CreateUserInventory (m_agentID, false);
meshFolder = m_inventoryService.GetFolderForType (m_agentID, InventoryType.Mesh, FolderType.Mesh);
}
InventoryItemBase itemBase = new InventoryItemBase (UUID.Random (), m_agentID) {
AssetType = (sbyte)AssetType.Mesh,
AssetID = meshAsset.ID,
CreatorId = m_agentID.ToString (),
Folder = meshFolder.ID,
InvType = (int)InventoryType.Texture,
Name = "(Mesh) - " + assetName,
CurrentPermissions = (uint)PermissionMask.All,
BasePermissions = (uint)PermissionMask.All,
EveryOnePermissions = everyoneMask,
GroupPermissions = groupMask,
NextPermissions = nextOwnerMask
};
//Bad... but whatever
m_inventoryService.AddItem (itemBase);
pbs.SculptEntry = true;
pbs.SculptTexture = meshAsset.ID;
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 ();
int physicsShapeType = inner_instance_list ["physics_shape_type"].AsInteger ();
// not currently used int material = inner_instance_list["material"].AsInteger();
// not currently used int mesh = inner_instance_list["mesh"].AsInteger();
SceneObjectPart prim = new SceneObjectPart (m_agentID, pbs, position, Quaternion.Identity,
Vector3.Zero, assetName) { Scale = scale, AbsolutePosition = position };
rotations.Add (rotation);
positions.Add (position);
prim.UUID = UUID.Random ();
prim.CreatorID = m_agentID;
prim.OwnerID = m_agentID;
prim.GroupID = UUID.Zero;
prim.LastOwnerID = m_agentID;
prim.CreationDate = Util.UnixTimeSinceEpoch ();
prim.Name = assetName;
prim.Description = "";
prim.PhysicsType = (byte)physicsShapeType;
prim.BaseMask = (uint)PermissionMask.All;
prim.EveryoneMask = everyoneMask;
prim.NextOwnerMask = nextOwnerMask;
prim.GroupMask = groupMask;
prim.OwnerMask = (uint)PermissionMask.All;
if (grp == null)
grp = new SceneObjectGroup (prim, null);
else
grp.AddChild (prim, i + 1);
grp.RootPart.IsAttachment = false;
}
if (grp != null) { // unlikely not to have anything but itis possible
if (grp.ChildrenList.Count > 1) //Fix first link #
grp.RootPart.LinkNum++;
Vector3 rootPos = positions [0];
grp.SetAbsolutePosition (false, rootPos);
for (int i = 0; i < positions.Count; i++) {
Vector3 offset = positions [i] - rootPos;
grp.ChildrenList [i].SetOffsetPosition (offset);
}
//grp.Rotation = rotations[0];
for (int i = 0; i < rotations.Count; i++) {
if (i != 0)
grp.ChildrenList [i].SetRotationOffset (false, rotations [i], false);
}
grp.UpdateGroupRotationR (rotations [0]);
data = Encoding.ASCII.GetBytes (grp.ToXml2 ());
}
}
break;
}
AssetBase asset = new AssetBase (assetID, assetName, (AssetType)assType, m_agentID) { Data = data };
asset.ID = m_assetService.Store (asset);
assetID = asset.ID;
InventoryItemBase item = new InventoryItemBase {
Owner = m_agentID,
CreatorId = m_agentID.ToString (),
ID = inventoryItem,
AssetID = asset.ID,
Description = assetDescription,
Name = assetName,
AssetType = assType,
InvType = inType,
Folder = parentFolder,
CurrentPermissions = (uint)PermissionMask.All,
BasePermissions = (uint)PermissionMask.All,
EveryOnePermissions = everyoneMask,
NextPermissions = nextOwnerMask,
GroupPermissions = groupMask,
CreationDate = Util.UnixTimeSinceEpoch ()
};
m_inventoryService.AddItem (item);
return assetID;
}
// Event generated when some property of a prim changes.
void EventManager_OnSceneObjectPartUpdated(SceneObjectPart sop, bool isFullUpdate)
{
}
private void LinkNonRootPart(SceneObjectPart part, Vector3 oldGroupPosition, Quaternion oldGroupRotation,
int linkNum)
{
Quaternion WorldRot = oldGroupRotation*part.GetRotationOffset();
// first fix from old local to world position
Vector3 axPos = part.OffsetPosition;
axPos *= oldGroupRotation;
part.SetGroupPosition(oldGroupPosition + axPos);
//offset
part.SetRotationOffset(false, WorldRot, false);
// have it in world coords lets fix other things
m_scene.SceneGraph.LinkPartToSOG(this, part, linkNum);
part.CreateSelected = true;
// now lets move to the new parent frame
Quaternion rootRotation = m_rootPart.GetRotationOffset();
Vector3 pos = part.GroupPosition - AbsolutePosition;
pos *= Quaternion.Inverse(rootRotation);
part.SetOffsetPosition(pos);
Quaternion newRot = Quaternion.Inverse(rootRotation)*WorldRot;
part.SetRotationOffset(false, newRot, false);
// caller will tell the rest about this position changes.
}
/// <summary>
/// Add a child to the group, set the parent id's and then set the link number
/// </summary>
/// <param name="child"></param>
/// <param name="linkNum"></param>
/// <returns></returns>
public bool AddChild(ISceneChildEntity child, int linkNum)
{
lock (m_partsLock)
{
if (child is SceneObjectPart)
{
SceneObjectPart part = (SceneObjectPart) child;
//Root part is first
if (m_partsList.Count == 0)
{
m_rootPart = part;
}
//Set the parent prim
part.SetParent(this);
if (m_rootPart.LocalId != 0 && !part.IsRoot)
part.SetParentLocalId(m_rootPart.LocalId);
else
part.SetParentLocalId(0);
//Fix the link num
part.LinkNum = linkNum;
if (!m_parts.ContainsKey(child.UUID))
{
m_parts.Add(child.UUID, part);
m_partsList.Add(part);
m_ValidgrpOOB = false;
}
return true;
}
}
return false;
}
/// <summary>
/// Set a part to act as the root part for this scene object
/// </summary>
/// <param name="part"></param>
public void SetRootPart(SceneObjectPart part)
{
if (part == null)
throw new ArgumentNullException("part");
m_rootPart = part;
if (!IsAttachment)
part.SetParentLocalId(0);
AddChild(part, part.LinkNum);
}
/// <summary>
/// Fix all the vehicle params after rebuilding the representation
/// </summary>
/// <param name="part"></param>
private void FixVehicleParams(SceneObjectPart part)
{
part.PhysActor.VehicleType = part.VehicleType;
foreach (OSD param in part.VehicleFlags)
{
part.PhysActor.VehicleFlags(param.AsInteger(), false);
}
foreach (KeyValuePair<string, OSD> param in part.VehicleParameters)
{
if (param.Value.Type == OSDType.Real)
part.PhysActor.VehicleFloatParam(int.Parse(param.Key), (float) param.Value.AsReal());
else if (param.Value.Type == OSDType.Array)
{
OSDArray a = (OSDArray) param.Value;
if (a.Count == 3)
part.PhysActor.VehicleVectorParam(int.Parse(param.Key), param.Value.AsVector3());
else
part.PhysActor.VehicleRotationParam(int.Parse(param.Key), param.Value.AsQuaternion());
}
}
}
public virtual void OnGrabPart(SceneObjectPart part, Vector3 offsetPos, IClientAPI remoteClient)
{
part.StoreUndoState();
part.OnGrab(offsetPos, remoteClient);
}
public void SetPartOwner(SceneObjectPart part, UUID cAgentID, UUID cGroupID)
{
part.OwnerID = cAgentID;
part.GroupID = cGroupID;
}
/// <summary>
/// Add this child to the group and set the parent ID's,
/// but do NOT set the link number,
/// the caller wants to deal with it if they call this
/// </summary>
/// <param name="child"></param>
/// <returns></returns>
public bool LinkChild(ISceneChildEntity child)
{
lock (m_partsLock)
{
if (child is SceneObjectPart)
{
SceneObjectPart part = (SceneObjectPart) child;
//Root part is first
if (m_partsList.Count == 0)
{
m_rootPart = part;
}
//Set the parent prim
part.SetParent(this);
part.SetParentLocalId(m_rootPart.LocalId);
if (!m_parts.ContainsKey(child.UUID))
{
m_parts.Add(child.UUID, part);
m_partsList.Add(part);
m_ValidgrpOOB = false;
}
m_partsList.Sort(m_scene.SceneGraph.LinkSetSorter);
return true;
}
}
return false;
}
/// <summary>
/// Link the prims in a given group to this group
/// </summary>
/// <param name="grp">The group of prims which should be linked to this group</param>
public void LinkToGroup(ISceneEntity grp)
{
//MainConsole.Instance.DebugFormat(
// "[SCENE OBJECT GROUP]: Linking group with root part {0}, {1} to group with root part {2}, {3}",
// objectGroup.RootPart.Name, objectGroup.RootPart.UUID, RootPart.Name, RootPart.UUID);
if (!(grp is SceneObjectGroup))
return;
SceneObjectGroup objectGroup = (SceneObjectGroup) grp;
if (m_rootPart.PhysActor != null)
m_rootPart.PhysActor.BlockPhysicalReconstruction = true;
SceneObjectPart linkPart = objectGroup.m_rootPart;
Vector3 oldGroupPosition = linkPart.GroupPosition;
Quaternion oldRootRotation = linkPart.GetRotationOffset();
Quaternion parentRot = m_rootPart.GetRotationOffset();
linkPart.SetGroupPosition(AbsolutePosition); // just change it without doing anything else
Vector3 axPos = oldGroupPosition - AbsolutePosition;
axPos *= Quaternion.Inverse(parentRot);
linkPart.SetOffsetPosition(axPos);
Quaternion newRot = Quaternion.Inverse(parentRot)*oldRootRotation;
linkPart.SetRotationOffset(false, newRot, false);
//Fix the link number for the root
if (m_rootPart.LinkNum == 0)
m_rootPart.LinkNum = 1;
SceneObjectPart[] objectGroupChildren = new SceneObjectPart[objectGroup.ChildrenList.Count];
objectGroup.ChildrenList.CopyTo(objectGroupChildren, 0);
//Destroy the old group
m_scene.SceneGraph.DeleteEntity(objectGroup);
objectGroup.IsDeleted = true;
objectGroup.ClearChildren();
lock (m_partsLock)
{
int linkNum = 2;
//Add the root part to our group!
m_scene.SceneGraph.LinkPartToSOG(this, linkPart, linkNum++);
linkPart.CreateSelected = true;
linkPart.FixOffsetPosition(linkPart.OffsetPosition, true); // nasty let all know about where this is
// let physics link it
if (linkPart.PhysActor != null && m_rootPart.PhysActor != null)
{
if (linkPart.PhysicsType != (byte) PhysicsShapeType.None)
linkPart.PhysActor.link(m_rootPart.PhysActor);
}
//rest of parts
foreach (
SceneObjectPart part in objectGroupChildren.Where(part => part.UUID != objectGroup.m_rootPart.UUID))
{
LinkNonRootPart(part, oldGroupPosition, oldRootRotation, linkNum++);
part.FixOffsetPosition(part.OffsetPosition, true);
if (part.PhysActor != null && m_rootPart.PhysActor != null)
part.PhysActor.link(m_rootPart.PhysActor);
}
}
// Here's the deal, this is ABSOLUTELY CRITICAL so the physics scene gets the update about the
// position of linkset prims. IF YOU CHANGE THIS, YOU MUST TEST colliding with just linked and
// unmoved prims!
m_ValidgrpOOB = false;
ResetChildPrimPhysicsPositions();
if (m_rootPart.PhysActor != null)
m_rootPart.PhysActor.BlockPhysicalReconstruction = false;
}
/// <summary>
/// Constructor. This object is added to the scene later via AttachToScene()
/// </summary>
public SceneObjectGroup(UUID ownerID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape, string name,
IScene scene)
: this(scene)
{
SceneObjectPart part = new SceneObjectPart(ownerID, shape, pos, rot, Vector3.Zero, name);
SetRootPart(part);
//This has to be set, otherwise it will break things like rezzing objects in an area where crossing is disabled, but rez isn't
m_lastSignificantPosition = pos;
m_ValidgrpOOB = false;
}
public SceneObjectGroup(SceneObjectPart part, IScene scene, bool AddToScene)
: this(scene)
{
if (!AddToScene)
m_isDeleted = true;
SetRootPart(part);
part.Scale = part.Shape.Scale; // temporary hack to update oobb
m_ValidgrpOOB = false;
}
/// <summary>
/// This constructor creates a SceneObjectGroup using a pre-existing SceneObjectPart.
/// The original SceneObjectPart will be used rather than a copy, preserving
/// its existing localID and UUID.
/// </summary>
public SceneObjectGroup(SceneObjectPart part, IScene scene)
: this(scene)
{
SetRootPart(part);
part.Scale = part.Shape.Scale; // temporary hack to update oobb
m_ValidgrpOOB = false;
}
/// <summary>
/// Parses ad request
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="AgentId"></param>
/// <returns></returns>
public byte[] ProcessAdd(Stream request, OSHttpResponse response, UUID AgentId)
{
IScenePresence avatar;
if (!m_scene.TryGetScenePresence(AgentId, out avatar))
return MainServer.BlankResponse;
OSDMap r = (OSDMap) OSDParser.Deserialize(HttpServerHandlerHelpers.ReadFully(request));
UploadObjectAssetMessage message = new UploadObjectAssetMessage();
try
{
message.Deserialize(r);
}
catch (Exception ex)
{
MainConsole.Instance.Error("[UploadObjectAssetModule]: Error de-serializing message " + ex);
message = null;
}
if (message == null)
{
response.StatusCode = 400; //501; //410; //404;
return
Encoding.UTF8.GetBytes(
"<llsd><map><key>error</key><string>Error parsing Object</string></map></llsd>");
}
Vector3 pos = avatar.AbsolutePosition + (Vector3.UnitX*avatar.Rotation);
Quaternion rot = Quaternion.Identity;
Vector3 rootpos = Vector3.Zero;
SceneObjectGroup rootGroup = null;
SceneObjectGroup[] allparts = new SceneObjectGroup[message.Objects.Length];
for (int i = 0; i < message.Objects.Length; i++)
{
UploadObjectAssetMessage.Object obj = message.Objects[i];
PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
if (i == 0)
{
rootpos = obj.Position;
}
// Combine the extraparams data into it's ugly blob again....
//int bytelength = 0;
//for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
//{
// bytelength += obj.ExtraParams[extparams].ExtraParamData.Length;
//}
//byte[] extraparams = new byte[bytelength];
//int position = 0;
//for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
//{
// Buffer.BlockCopy(obj.ExtraParams[extparams].ExtraParamData, 0, extraparams, position,
// obj.ExtraParams[extparams].ExtraParamData.Length);
//
// position += obj.ExtraParams[extparams].ExtraParamData.Length;
// }
//pbs.ExtraParams = extraparams;
foreach (UploadObjectAssetMessage.Object.ExtraParam extraParam in obj.ExtraParams)
{
switch ((ushort) extraParam.Type)
{
case (ushort) ExtraParamType.Sculpt:
Primitive.SculptData sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
pbs.SculptEntry = true;
pbs.SculptTexture = obj.SculptID;
pbs.SculptType = (byte) sculpt.Type;
break;
case (ushort) ExtraParamType.Flexible:
Primitive.FlexibleData flex = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
pbs.FlexiEntry = true;
pbs.FlexiDrag = flex.Drag;
pbs.FlexiForceX = flex.Force.X;
pbs.FlexiForceY = flex.Force.Y;
pbs.FlexiForceZ = flex.Force.Z;
pbs.FlexiGravity = flex.Gravity;
pbs.FlexiSoftness = flex.Softness;
pbs.FlexiTension = flex.Tension;
pbs.FlexiWind = flex.Wind;
break;
case (ushort) ExtraParamType.Light:
Primitive.LightData light = new Primitive.LightData(extraParam.ExtraParamData, 0);
pbs.LightColorA = light.Color.A;
pbs.LightColorB = light.Color.B;
pbs.LightColorG = light.Color.G;
pbs.LightColorR = light.Color.R;
pbs.LightCutoff = light.Cutoff;
pbs.LightEntry = true;
pbs.LightFalloff = light.Falloff;
pbs.LightIntensity = light.Intensity;
pbs.LightRadius = light.Radius;
break;
case 0x40:
pbs.ReadProjectionData(extraParam.ExtraParamData, 0);
break;
}
}
pbs.PathBegin = (ushort) obj.PathBegin;
pbs.PathCurve = (byte) obj.PathCurve;
pbs.PathEnd = (ushort) obj.PathEnd;
pbs.PathRadiusOffset = (sbyte) obj.RadiusOffset;
pbs.PathRevolutions = (byte) obj.Revolutions;
pbs.PathScaleX = (byte) obj.ScaleX;
pbs.PathScaleY = (byte) obj.ScaleY;
pbs.PathShearX = (byte) obj.ShearX;
pbs.PathShearY = (byte) obj.ShearY;
pbs.PathSkew = (sbyte) obj.Skew;
pbs.PathTaperX = (sbyte) obj.TaperX;
pbs.PathTaperY = (sbyte) obj.TaperY;
pbs.PathTwist = (sbyte) obj.Twist;
pbs.PathTwistBegin = (sbyte) obj.TwistBegin;
pbs.HollowShape = (HollowShape) obj.ProfileHollow;
pbs.PCode = (byte) PCode.Prim;
pbs.ProfileBegin = (ushort) obj.ProfileBegin;
pbs.ProfileCurve = (byte) obj.ProfileCurve;
pbs.ProfileEnd = (ushort) obj.ProfileEnd;
pbs.Scale = obj.Scale;
pbs.State = 0;
SceneObjectPart prim = new SceneObjectPart(AgentId, pbs, obj.Position, obj.Rotation,
Vector3.Zero, obj.Name)
{
UUID = UUID.Random(),
CreatorID = AgentId,
OwnerID = AgentId,
GroupID = obj.GroupID
};
prim.LastOwnerID = prim.OwnerID;
prim.CreationDate = Util.UnixTimeSinceEpoch();
prim.Name = obj.Name;
prim.Description = "";
prim.PayPrice[0] = -2;
prim.PayPrice[1] = -2;
prim.PayPrice[2] = -2;
prim.PayPrice[3] = -2;
prim.PayPrice[4] = -2;
Primitive.TextureEntry tmp =
new Primitive.TextureEntry(UUID.Parse("89556747-24cb-43ed-920b-47caed15465f"));
for (int j = 0; j < obj.Faces.Length; j++)
{
UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
Primitive.TextureEntryFace primFace = tmp.CreateFace((uint) j);
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 & 1) != 0);
primFace.OffsetU = face.OffsetS;
primFace.OffsetV = face.OffsetT;
primFace.RepeatU = face.ScaleS;
primFace.RepeatV = face.ScaleT;
primFace.TexMapType = (MappingType) (face.MediaFlags & 6);
}
pbs.TextureEntry = tmp.GetBytes();
prim.Shape = pbs;
prim.Scale = obj.Scale;
SceneObjectGroup grp = new SceneObjectGroup(prim, m_scene);
prim.ParentID = 0;
if (i == 0)
rootGroup = grp;
grp.AbsolutePosition = obj.Position;
prim.SetRotationOffset(true, obj.Rotation, true);
grp.RootPart.IsAttachment = false;
string reason;
if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos, out reason))
{
m_scene.SceneGraph.AddPrimToScene(grp);
grp.AbsolutePosition = obj.Position;
}
else
{
//Stop now then
avatar.ControllingClient.SendAlertMessage("You do not have permission to rez objects here: " +
reason);
return MainServer.BlankResponse;
}
allparts[i] = grp;
}
if (rootGroup != null) {
for (int j = 1; j < allparts.Length; j++) {
rootGroup.LinkToGroup (allparts [j]);
}
rootGroup.ScheduleGroupUpdate (PrimUpdateFlags.ForcedFullUpdate);
pos = m_scene.SceneGraph.GetNewRezLocation (Vector3.Zero, rootpos, UUID.Zero, rot, 1, 1, true, allparts [0].GroupScale (), false);
} else
MainConsole.Instance.Error ("[UploadObjectAssetModule]: Unable to locate root group!");
OSDMap map = new OSDMap();
map["local_id"] = allparts[0].LocalId;
return OSDParser.SerializeLLSDXmlBytes(map);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="part">
/// A <see cref="SceneObjectPart" />
/// </param>
public SceneObjectPartInventory (SceneObjectPart part)
{
m_part = part;
}
