From c062138dad42ef7e52bbcb27c346ddecab94c5af Mon Sep 17 00:00:00 2001 From: Diva Canto Date: Sat, 30 Apr 2011 12:23:40 -0700 Subject: Moved several cap-based-service-providing modules from where they were into a newly created CoreModules/Caps. Not all. --- .../CoreModules/Caps/ObjectCaps/ObjectAdd.cs | 370 +++++++++++++++++++++ 1 file changed, 370 insertions(+) create mode 100644 OpenSim/Region/CoreModules/Caps/ObjectCaps/ObjectAdd.cs (limited to 'OpenSim/Region/CoreModules/Caps/ObjectCaps/ObjectAdd.cs') diff --git a/OpenSim/Region/CoreModules/Caps/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/CoreModules/Caps/ObjectCaps/ObjectAdd.cs new file mode 100644 index 0000000..5cd0fe7 --- /dev/null +++ b/OpenSim/Region/CoreModules/Caps/ObjectCaps/ObjectAdd.cs @@ -0,0 +1,370 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Reflection; +using log4net; +using Nini.Config; +using OpenMetaverse; +using OpenMetaverse.StructuredData; +using OpenSim.Framework; +using OpenSim.Framework.Servers; +using OpenSim.Framework.Servers.HttpServer; +using OpenSim.Region.Framework.Interfaces; +using OpenSim.Region.Framework.Scenes; +using Caps=OpenSim.Framework.Capabilities.Caps; + +namespace OpenSim.Region.CoreModules.Capabilities +{ + public class ObjectAdd : IRegionModule + { +// private static readonly ILog m_log = +// LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); + + private Scene m_scene; + #region IRegionModule Members + + public void Initialise(Scene pScene, IConfigSource pSource) + { + m_scene = pScene; + m_scene.EventManager.OnRegisterCaps += RegisterCaps; + } + + public void PostInitialise() + { + + } + + public void RegisterCaps(UUID agentID, Caps caps) + { + UUID capuuid = UUID.Random(); + +// m_log.InfoFormat("[OBJECTADD]: {0}", "/CAPS/OA/" + capuuid + "/"); + + caps.RegisterHandler("ObjectAdd", + new RestHTTPHandler("POST", "/CAPS/OA/" + capuuid + "/", + delegate(Hashtable m_dhttpMethod) + { + return ProcessAdd(m_dhttpMethod, agentID, caps); + })); + } + + public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap) + { + Hashtable responsedata = new Hashtable(); + responsedata["int_response_code"] = 400; //501; //410; //404; + responsedata["content_type"] = "text/plain"; + responsedata["keepalive"] = false; + responsedata["str_response_string"] = "Request wasn't what was expected"; + ScenePresence avatar; + + if (!m_scene.TryGetScenePresence(AgentId, out avatar)) + return responsedata; + + + OSD r = OSDParser.DeserializeLLSDXml((string)request["requestbody"]); + //UUID session_id = UUID.Zero; + bool bypass_raycast = false; + uint everyone_mask = 0; + uint group_mask = 0; + uint next_owner_mask = 0; + uint flags = 0; + UUID group_id = UUID.Zero; + int hollow = 0; + int material = 0; + int p_code = 0; + int path_begin = 0; + int path_curve = 0; + int path_end = 0; + int path_radius_offset = 0; + int path_revolutions = 0; + int path_scale_x = 0; + int path_scale_y = 0; + int path_shear_x = 0; + int path_shear_y = 0; + int path_skew = 0; + int path_taper_x = 0; + int path_taper_y = 0; + int path_twist = 0; + int path_twist_begin = 0; + int profile_begin = 0; + int profile_curve = 0; + int profile_end = 0; + Vector3 ray_end = Vector3.Zero; + bool ray_end_is_intersection = false; + Vector3 ray_start = Vector3.Zero; + UUID ray_target_id = UUID.Zero; + Quaternion rotation = Quaternion.Identity; + Vector3 scale = Vector3.Zero; + int state = 0; + + if (r.Type != OSDType.Map) // not a proper req + return responsedata; + + OSDMap rm = (OSDMap)r; + + if (rm.ContainsKey("ObjectData")) //v2 + { + if (rm["ObjectData"].Type != OSDType.Map) + { + responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format"; + return responsedata; + } + + OSDMap ObjMap = (OSDMap) rm["ObjectData"]; + + bypass_raycast = ObjMap["BypassRaycast"].AsBoolean(); + everyone_mask = readuintval(ObjMap["EveryoneMask"]); + flags = readuintval(ObjMap["Flags"]); + group_mask = readuintval(ObjMap["GroupMask"]); + material = ObjMap["Material"].AsInteger(); + next_owner_mask = readuintval(ObjMap["NextOwnerMask"]); + p_code = ObjMap["PCode"].AsInteger(); + + if (ObjMap.ContainsKey("Path")) + { + if (ObjMap["Path"].Type != OSDType.Map) + { + responsedata["str_response_string"] = "Has Path key, but data not in expected format"; + return responsedata; + } + + OSDMap PathMap = (OSDMap)ObjMap["Path"]; + path_begin = PathMap["Begin"].AsInteger(); + path_curve = PathMap["Curve"].AsInteger(); + path_end = PathMap["End"].AsInteger(); + path_radius_offset = PathMap["RadiusOffset"].AsInteger(); + path_revolutions = PathMap["Revolutions"].AsInteger(); + path_scale_x = PathMap["ScaleX"].AsInteger(); + path_scale_y = PathMap["ScaleY"].AsInteger(); + path_shear_x = PathMap["ShearX"].AsInteger(); + path_shear_y = PathMap["ShearY"].AsInteger(); + path_skew = PathMap["Skew"].AsInteger(); + path_taper_x = PathMap["TaperX"].AsInteger(); + path_taper_y = PathMap["TaperY"].AsInteger(); + path_twist = PathMap["Twist"].AsInteger(); + path_twist_begin = PathMap["TwistBegin"].AsInteger(); + + } + + if (ObjMap.ContainsKey("Profile")) + { + if (ObjMap["Profile"].Type != OSDType.Map) + { + responsedata["str_response_string"] = "Has Profile key, but data not in expected format"; + return responsedata; + } + + OSDMap ProfileMap = (OSDMap)ObjMap["Profile"]; + + profile_begin = ProfileMap["Begin"].AsInteger(); + profile_curve = ProfileMap["Curve"].AsInteger(); + profile_end = ProfileMap["End"].AsInteger(); + hollow = ProfileMap["Hollow"].AsInteger(); + } + ray_end_is_intersection = ObjMap["RayEndIsIntersection"].AsBoolean(); + + ray_target_id = ObjMap["RayTargetId"].AsUUID(); + state = ObjMap["State"].AsInteger(); + try + { + ray_end = ((OSDArray) ObjMap["RayEnd"]).AsVector3(); + ray_start = ((OSDArray) ObjMap["RayStart"]).AsVector3(); + scale = ((OSDArray) ObjMap["Scale"]).AsVector3(); + rotation = ((OSDArray)ObjMap["Rotation"]).AsQuaternion(); + } + catch (Exception) + { + responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format"; + return responsedata; + } + + if (rm.ContainsKey("AgentData")) + { + if (rm["AgentData"].Type != OSDType.Map) + { + responsedata["str_response_string"] = "Has AgentData key, but data not in expected format"; + return responsedata; + } + + OSDMap AgentDataMap = (OSDMap) rm["AgentData"]; + + //session_id = AgentDataMap["SessionId"].AsUUID(); + group_id = AgentDataMap["GroupId"].AsUUID(); + } + + } + else + { //v1 + bypass_raycast = rm["bypass_raycast"].AsBoolean(); + + everyone_mask = readuintval(rm["everyone_mask"]); + flags = readuintval(rm["flags"]); + group_id = rm["group_id"].AsUUID(); + group_mask = readuintval(rm["group_mask"]); + hollow = rm["hollow"].AsInteger(); + material = rm["material"].AsInteger(); + next_owner_mask = readuintval(rm["next_owner_mask"]); + hollow = rm["hollow"].AsInteger(); + p_code = rm["p_code"].AsInteger(); + path_begin = rm["path_begin"].AsInteger(); + path_curve = rm["path_curve"].AsInteger(); + path_end = rm["path_end"].AsInteger(); + path_radius_offset = rm["path_radius_offset"].AsInteger(); + path_revolutions = rm["path_revolutions"].AsInteger(); + path_scale_x = rm["path_scale_x"].AsInteger(); + path_scale_y = rm["path_scale_y"].AsInteger(); + path_shear_x = rm["path_shear_x"].AsInteger(); + path_shear_y = rm["path_shear_y"].AsInteger(); + path_skew = rm["path_skew"].AsInteger(); + path_taper_x = rm["path_taper_x"].AsInteger(); + path_taper_y = rm["path_taper_y"].AsInteger(); + path_twist = rm["path_twist"].AsInteger(); + path_twist_begin = rm["path_twist_begin"].AsInteger(); + profile_begin = rm["profile_begin"].AsInteger(); + profile_curve = rm["profile_curve"].AsInteger(); + profile_end = rm["profile_end"].AsInteger(); + + ray_end_is_intersection = rm["ray_end_is_intersection"].AsBoolean(); + + ray_target_id = rm["ray_target_id"].AsUUID(); + + + //session_id = rm["session_id"].AsUUID(); + state = rm["state"].AsInteger(); + try + { + ray_end = ((OSDArray)rm["ray_end"]).AsVector3(); + ray_start = ((OSDArray)rm["ray_start"]).AsVector3(); + rotation = ((OSDArray)rm["rotation"]).AsQuaternion(); + scale = ((OSDArray)rm["scale"]).AsVector3(); + } + catch (Exception) + { + responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format"; + return responsedata; + } + } + + + + Vector3 pos = m_scene.GetNewRezLocation(ray_start, ray_end, ray_target_id, rotation, (bypass_raycast) ? (byte)1 : (byte)0, (ray_end_is_intersection) ? (byte)1 : (byte)0, true, scale, false); + + PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox(); + + pbs.PathBegin = (ushort)path_begin; + pbs.PathCurve = (byte)path_curve; + pbs.PathEnd = (ushort)path_end; + pbs.PathRadiusOffset = (sbyte)path_radius_offset; + pbs.PathRevolutions = (byte)path_revolutions; + pbs.PathScaleX = (byte)path_scale_x; + pbs.PathScaleY = (byte)path_scale_y; + pbs.PathShearX = (byte) path_shear_x; + pbs.PathShearY = (byte)path_shear_y; + pbs.PathSkew = (sbyte)path_skew; + pbs.PathTaperX = (sbyte)path_taper_x; + pbs.PathTaperY = (sbyte)path_taper_y; + pbs.PathTwist = (sbyte)path_twist; + pbs.PathTwistBegin = (sbyte)path_twist_begin; + pbs.HollowShape = (HollowShape) hollow; + pbs.PCode = (byte)p_code; + pbs.ProfileBegin = (ushort) profile_begin; + pbs.ProfileCurve = (byte) profile_curve; + pbs.ProfileEnd = (ushort)profile_end; + pbs.Scale = scale; + pbs.State = (byte)state; + + SceneObjectGroup obj = null; ; + + if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos)) + { + // rez ON the ground, not IN the ground + // pos.Z += 0.25F; + + obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs); + } + + + if (obj == null) + return responsedata; + + SceneObjectPart rootpart = obj.RootPart; + rootpart.Shape = pbs; + rootpart.Flags |= (PrimFlags)flags; + rootpart.EveryoneMask = everyone_mask; + rootpart.GroupID = group_id; + rootpart.GroupMask = group_mask; + rootpart.NextOwnerMask = next_owner_mask; + rootpart.Material = (byte)material; + + + + m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor); + + responsedata["int_response_code"] = 200; //501; //410; //404; + responsedata["content_type"] = "text/plain"; + responsedata["keepalive"] = false; + responsedata["str_response_string"] = String.Format("local_id{0}",ConvertUintToBytes(obj.LocalId)); + + return responsedata; + } + + private uint readuintval(OSD obj) + { + byte[] tmp = obj.AsBinary(); + if (BitConverter.IsLittleEndian) + Array.Reverse(tmp); + return Utils.BytesToUInt(tmp); + + } + private string ConvertUintToBytes(uint val) + { + byte[] resultbytes = Utils.UIntToBytes(val); + if (BitConverter.IsLittleEndian) + Array.Reverse(resultbytes); + return String.Format("{0}",Convert.ToBase64String(resultbytes)); + } + + public void Close() + { + + } + + public string Name + { + get { return "ObjectAddModule"; } + } + + public bool IsSharedModule + { + get { return false; } + } + + #endregion + } +} -- cgit v1.1