public void doChangeObject(SceneObjectPart part, ObjectChangeData data) { // TODO this still as excessive *.Schedule*Update()s if (part != null && part.ParentGroup != null) { ObjectChangeType change = data.change; bool togroup = ((change & ObjectChangeType.Group) != 0); // bool uniform = ((what & ObjectChangeType.UniformScale) != 0); not in use SceneObjectGroup group = part.ParentGroup; PhysicsActor pha = group.RootPart.PhysActor; updatetype updateType = updatetype.none; if (togroup) { // related to group if ((change & (ObjectChangeType.Rotation | ObjectChangeType.Position)) != 0) { if ((change & ObjectChangeType.Rotation) != 0) { group.RootPart.UpdateRotation(data.rotation); updateType = updatetype.none; } if ((change & ObjectChangeType.Position) != 0) { if (IsAttachment || m_scene.Permissions.CanObjectEntry(group.UUID, false, data.position)) UpdateGroupPosition(data.position); updateType = updatetype.groupterse; } else // ugly rotation update of all parts { group.ResetChildPrimPhysicsPositions(); } } if ((change & ObjectChangeType.Scale) != 0) { if (pha != null) pha.Building = true; group.GroupResize(data.scale); updateType = updatetype.none; if (pha != null) pha.Building = false; } } else { // related to single prim in a link-set ( ie group) if (pha != null) pha.Building = true; // root part is special // parts offset positions or rotations need to change also if (part == group.RootPart) { if ((change & ObjectChangeType.Rotation) != 0) group.UpdateRootRotation(data.rotation); if ((change & ObjectChangeType.Position) != 0) group.UpdateRootPosition(data.position); if ((change & ObjectChangeType.Scale) != 0) part.Resize(data.scale); } else { if ((change & ObjectChangeType.Position) != 0) { part.OffsetPosition = data.position; updateType = updatetype.partterse; } if ((change & ObjectChangeType.Rotation) != 0) { part.UpdateRotation(data.rotation); updateType = updatetype.none; } if ((change & ObjectChangeType.Scale) != 0) { part.Resize(data.scale); updateType = updatetype.none; } } if (pha != null) pha.Building = false; } if (updateType != updatetype.none) { group.HasGroupChanged = true; switch (updateType) { case updatetype.partterse: part.ScheduleTerseUpdate(); break; case updatetype.partfull: part.ScheduleFullUpdate(); break; case updatetype.groupterse: group.ScheduleGroupForTerseUpdate(); break; case updatetype.groupfull: group.ScheduleGroupForFullUpdate(); break; default: break; } } } }
public void PlaybackState(SceneObjectPart part) { if (part != null) { part.Undoing = true; if (part.ParentID == 0) { part.ParentGroup.AbsolutePosition = Position; part.UpdateRotation(Rotation); part.ParentGroup.ScheduleGroupForTerseUpdate(); } else { part.OffsetPosition = Position; part.UpdateRotation(Rotation); part.Resize(Scale); part.ScheduleTerseUpdate(); } part.Undoing = false; } }
protected LSL_List SetPrimParams(SceneObjectPart part, LSL_List rules, string originFunc, ref uint rulesParsed) { if (part == null || part.ParentGroup == null || part.ParentGroup.IsDeleted) return new LSL_List(); int idx = 0; int idxStart = 0; SceneObjectGroup parentgrp = part.ParentGroup; bool positionChanged = false; LSL_Vector currentPosition = GetPartLocalPos(part); try { while (idx < rules.Length) { ++rulesParsed; int code = rules.GetLSLIntegerItem(idx++); int remain = rules.Length - idx; idxStart = idx; int face; LSL_Vector v; switch (code) { case ScriptBaseClass.PRIM_POSITION: case ScriptBaseClass.PRIM_POS_LOCAL: if (remain < 1) return new LSL_List(); try { v = rules.GetVector3Item(idx++); } catch(InvalidCastException) { if(code == ScriptBaseClass.PRIM_POSITION) Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POSITION: arg #{1} - parameter 1 must be vector", rulesParsed, idx - idxStart - 1)); else Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POS_LOCAL: arg #{1} - parameter 1 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } if (part.IsRoot && !part.ParentGroup.IsAttachment) currentPosition = GetSetPosTarget(part, v, currentPosition, true); else currentPosition = GetSetPosTarget(part, v, currentPosition, false); positionChanged = true; break; case ScriptBaseClass.PRIM_SIZE: if (remain < 1) return new LSL_List(); v=rules.GetVector3Item(idx++); SetScale(part, v); break; case ScriptBaseClass.PRIM_ROTATION: if (remain < 1) return new LSL_List(); LSL_Rotation q; try { q = rules.GetQuaternionItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_ROTATION: arg #{1} - parameter 1 must be rotation", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } // try to let this work as in SL... if (part.ParentID == 0 || (part.ParentGroup != null && part == part.ParentGroup.RootPart)) { // special case: If we are root, rotate complete SOG to new rotation SetRot(part, q); } else { // we are a child. The rotation values will be set to the one of root modified by rot, as in SL. Don't ask. SceneObjectPart rootPart = part.ParentGroup.RootPart; SetRot(part, rootPart.RotationOffset * (Quaternion)q); } break; case ScriptBaseClass.PRIM_TYPE: if (remain < 3) return new LSL_List(); try { code = (int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE: arg #{1} - parameter 1 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } remain = rules.Length - idx; float hollow; LSL_Vector twist; LSL_Vector taper_b; LSL_Vector topshear; float revolutions; float radiusoffset; float skew; LSL_Vector holesize; LSL_Vector profilecut; switch (code) { case ScriptBaseClass.PRIM_TYPE_BOX: if (remain < 6) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); // cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 3 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 5 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_BOX: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, taper_b, topshear, (byte)ProfileShape.Square, (byte)Extrusion.Straight); break; case ScriptBaseClass.PRIM_TYPE_CYLINDER: if (remain < 6) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); // cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_CYLINDER: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, taper_b, topshear, (byte)ProfileShape.Circle, (byte)Extrusion.Straight); break; case ScriptBaseClass.PRIM_TYPE_PRISM: if (remain < 6) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); //cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_PRISM: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, taper_b, topshear, (byte)ProfileShape.EquilateralTriangle, (byte)Extrusion.Straight); break; case ScriptBaseClass.PRIM_TYPE_SPHERE: if (remain < 5) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SPHERE: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); // cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SPHERE: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SPHERE: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SPHERE: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); // dimple } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SPHERE: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, taper_b, (byte)ProfileShape.HalfCircle, (byte)Extrusion.Curve1); break; case ScriptBaseClass.PRIM_TYPE_TORUS: if (remain < 11) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); //cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { holesize = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { profilecut = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 9 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); // taper_a } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 10 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { revolutions = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 11 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { radiusoffset = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 12 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { skew = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TORUS: arg #{1} - parameter 13 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, holesize, topshear, profilecut, taper_b, revolutions, radiusoffset, skew, (byte)ProfileShape.Circle, (byte)Extrusion.Curve1); break; case ScriptBaseClass.PRIM_TYPE_TUBE: if (remain < 11) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); //cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { holesize = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { profilecut = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 9 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); // taper_a } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 10 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { revolutions = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 11 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { radiusoffset = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 12 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { skew = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_TUBE: arg #{1} - parameter 13 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, holesize, topshear, profilecut, taper_b, revolutions, radiusoffset, skew, (byte)ProfileShape.Square, (byte)Extrusion.Curve1); break; case ScriptBaseClass.PRIM_TYPE_RING: if (remain < 11) return new LSL_List(); try { face = (int)rules.GetLSLIntegerItem(idx++); // holeshape } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { v = rules.GetVector3Item(idx++); //cut } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { hollow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { twist = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 6 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { holesize = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 7 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { topshear = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { profilecut = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 9 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { taper_b = rules.GetVector3Item(idx++); // taper_a } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 10 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { revolutions = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 11 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { radiusoffset = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 12 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { skew = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_RING: arg #{1} - parameter 13 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, face, v, hollow, twist, holesize, topshear, profilecut, taper_b, revolutions, radiusoffset, skew, (byte)ProfileShape.EquilateralTriangle, (byte)Extrusion.Curve1); break; case ScriptBaseClass.PRIM_TYPE_SCULPT: if (remain < 2) return new LSL_List(); string map = rules.Data[idx++].ToString(); try { face = (int)rules.GetLSLIntegerItem(idx++); // type } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TYPE, PRIM_TYPE_SCULPT: arg #{1} - parameter 4 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPrimitiveShapeParams(part, map, face, (byte)Extrusion.Curve1); break; } break; case ScriptBaseClass.PRIM_TEXTURE: if (remain < 5) return new LSL_List(); face=(int)rules.GetLSLIntegerItem(idx++); string tex; LSL_Vector repeats; LSL_Vector offsets; double rotation; tex = rules.Data[idx++].ToString(); try { repeats = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXTURE: arg #{1} - parameter 3 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { offsets = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXTURE: arg #{1} - parameter 4 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { rotation = (double)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXTURE: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetTexture(part, tex, face); ScaleTexture(part, repeats.x, repeats.y, face); OffsetTexture(part, offsets.x, offsets.y, face); RotateTexture(part, rotation, face); break; case ScriptBaseClass.PRIM_COLOR: if (remain < 3) return new LSL_List(); LSL_Vector color; double alpha; try { face = (int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_COLOR: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { color = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_COLOR: arg #{1} - parameter 3 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { alpha = (double)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_COLOR: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } part.SetFaceColorAlpha(face, color, alpha); break; case ScriptBaseClass.PRIM_FLEXIBLE: if (remain < 7) return new LSL_List(); bool flexi; int softness; float gravity; float friction; float wind; float tension; LSL_Vector force; try { flexi = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { softness = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { gravity = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { friction = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { wind = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 6 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { tension = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 7 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { force = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FLEXIBLE: arg #{1} - parameter 8 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetFlexi(part, flexi, softness, gravity, friction, wind, tension, force); break; case ScriptBaseClass.PRIM_POINT_LIGHT: if (remain < 5) return new LSL_List(); bool light; LSL_Vector lightcolor; float intensity; float radius; float falloff; try { light = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POINT_LIGHT: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { lightcolor = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POINT_LIGHT: arg #{1} - parameter 3 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { intensity = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POINT_LIGHT: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { radius = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POINT_LIGHT: arg #{1} - parameter 5 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { falloff = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_POINT_LIGHT: arg #{1} - parameter 6 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetPointLight(part, light, lightcolor, intensity, radius, falloff); break; case ScriptBaseClass.PRIM_GLOW: if (remain < 2) return new LSL_List(); float glow; try { face = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_GLOW: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { glow = (float)rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_GLOW: arg #{1} - parameter 3 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetGlow(part, face, glow); break; case ScriptBaseClass.PRIM_BUMP_SHINY: if (remain < 3) return new LSL_List(); int shiny; Bumpiness bump; try { face = (int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_BUMP_SHINY: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { shiny = (int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_BUMP_SHINY: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { bump = (Bumpiness)(int)rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_BUMP_SHINY: arg #{1} - parameter 4 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetShiny(part, face, shiny, bump); break; case ScriptBaseClass.PRIM_FULLBRIGHT: if (remain < 2) return new LSL_List(); bool st; try { face = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FULLBRIGHT: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { st = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_FULLBRIGHT: arg #{1} - parameter 4 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetFullBright(part, face , st); break; case ScriptBaseClass.PRIM_MATERIAL: if (remain < 1) return new LSL_List(); int mat; try { mat = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_MATERIAL: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } if (mat < 0 || mat > 7) return new LSL_List(); part.Material = Convert.ToByte(mat); break; case ScriptBaseClass.PRIM_PHANTOM: if (remain < 1) return new LSL_List(); string ph = rules.Data[idx++].ToString(); part.ParentGroup.ScriptSetPhantomStatus(ph.Equals("1")); break; case ScriptBaseClass.PRIM_PHYSICS: if (remain < 1) return new LSL_List(); string phy = rules.Data[idx++].ToString(); part.ScriptSetPhysicsStatus(phy.Equals("1")); break; case ScriptBaseClass.PRIM_PHYSICS_SHAPE_TYPE: if (remain < 1) return new LSL_List(); int shape_type; try { shape_type = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_PHYSICS_SHAPE_TYPE: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } ExtraPhysicsData physdata = new ExtraPhysicsData(); physdata.Density = part.Density; physdata.Bounce = part.Restitution; physdata.GravitationModifier = part.GravityModifier; physdata.PhysShapeType = (PhysShapeType)shape_type; part.UpdateExtraPhysics(physdata); break; case (int)ScriptBaseClass.PRIM_PHYSICS_MATERIAL: if (remain < 5) return new LSL_List(); int material_bits = rules.GetLSLIntegerItem(idx++); float material_density = (float)rules.GetLSLFloatItem(idx++); float material_friction = (float)rules.GetLSLFloatItem(idx++); float material_restitution = (float)rules.GetLSLFloatItem(idx++); float material_gravity_modifier = (float)rules.GetLSLFloatItem(idx++); SetPhysicsMaterial(part, material_bits, material_density, material_friction, material_restitution, material_gravity_modifier); break; case (int)ScriptBaseClass.PRIM_TEMP_ON_REZ: if (remain < 1) return new LSL_List(); string temp = rules.Data[idx++].ToString(); part.ParentGroup.ScriptSetTemporaryStatus(temp.Equals("1")); break; case ScriptBaseClass.PRIM_TEXGEN: if (remain < 2) return new LSL_List(); //face,type int style; try { face = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXGEN: arg #{1} - parameter 2 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { style = rules.GetLSLIntegerItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXGEN: arg #{1} - parameter 3 must be integer", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetTexGen(part, face, style); break; case ScriptBaseClass.PRIM_TEXT: if (remain < 3) return new LSL_List(); string primText; LSL_Vector primTextColor; LSL_Float primTextAlpha; try { primText = rules.GetLSLStringItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXT: arg #{1} - parameter 2 must be string", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { primTextColor = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXT: arg #{1} - parameter 3 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { primTextAlpha = rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_TEXT: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } Vector3 av3 = Util.Clip(primTextColor, 0.0f, 1.0f); part.SetText(primText, av3, Util.Clip((float)primTextAlpha, 0.0f, 1.0f)); break; case ScriptBaseClass.PRIM_NAME: if (remain < 1) return new LSL_List(); try { string primName = rules.GetLSLStringItem(idx++); part.Name = primName; } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_NAME: arg #{1} - parameter 2 must be string", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } break; case ScriptBaseClass.PRIM_DESC: if (remain < 1) return new LSL_List(); try { string primDesc = rules.GetLSLStringItem(idx++); part.Description = primDesc; } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_DESC: arg #{1} - parameter 2 must be string", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } break; case ScriptBaseClass.PRIM_ROT_LOCAL: if (remain < 1) return new LSL_List(); LSL_Rotation rot; try { rot = rules.GetQuaternionItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_ROT_LOCAL: arg #{1} - parameter 2 must be rotation", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } SetRot(part, rot); break; case ScriptBaseClass.PRIM_OMEGA: if (remain < 3) return new LSL_List(); LSL_Vector axis; LSL_Float spinrate; LSL_Float gain; try { axis = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_OMEGA: arg #{1} - parameter 2 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { spinrate = rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_OMEGA: arg #{1} - parameter 3 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } try { gain = rules.GetLSLFloatItem(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_OMEGA: arg #{1} - parameter 4 must be float", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } TargetOmega(part, axis, (double)spinrate, (double)gain); break; case ScriptBaseClass.PRIM_SLICE: if (remain < 1) return new LSL_List(); LSL_Vector slice; try { slice = rules.GetVector3Item(idx++); } catch(InvalidCastException) { Error(originFunc, string.Format("Error running rule #{0} -> PRIM_SLICE: arg #{1} - parameter 2 must be vector", rulesParsed, idx - idxStart - 1)); return new LSL_List(); } part.UpdateSlice((float)slice.x, (float)slice.y); break; case ScriptBaseClass.PRIM_LINK_TARGET: if (remain < 3) // setting to 3 on the basis that parsing any usage of PRIM_LINK_TARGET that has nothing following it is pointless. return new LSL_List(); return rules.GetSublist(idx, -1); default: Error(originFunc, string.Format("Error running rule #{0}: arg #{1} - unsupported parameter", rulesParsed, idx - idxStart)); return new LSL_List(); } } } catch (InvalidCastException e) { Error(originFunc, string.Format("Error running rule #{0}: arg #{1} - ", rulesParsed, idx - idxStart) + e.Message); } finally { if (positionChanged) { if (part.ParentGroup.RootPart == part) { SceneObjectGroup parent = part.ParentGroup; // Util.FireAndForget(delegate(object x) { parent.UpdateGroupPosition(currentPosition); // }); } else { part.OffsetPosition = currentPosition; // SceneObjectGroup parent = part.ParentGroup; // parent.HasGroupChanged = true; // parent.ScheduleGroupForTerseUpdate(); part.ScheduleTerseUpdate(); } } } return new LSL_List(); }
/// <summary> /// set object position, optionally capping the distance. /// </summary> /// <param name="part"></param> /// <param name="targetPos"></param> /// <param name="adjust">if TRUE, will cap the distance to 10m.</param> protected void SetPos(SceneObjectPart part, LSL_Vector targetPos, bool adjust) { if (part == null || part.ParentGroup == null || part.ParentGroup.IsDeleted) return; LSL_Vector currentPos = GetPartLocalPos(part); LSL_Vector toPos = GetSetPosTarget(part, targetPos, currentPos, adjust); if (part.ParentGroup.RootPart == part) { SceneObjectGroup parent = part.ParentGroup; if (!World.Permissions.CanObjectEntry(parent.UUID, false, (Vector3)toPos)) return; parent.UpdateGroupPosition((Vector3)toPos); } else { part.OffsetPosition = (Vector3)toPos; // SceneObjectGroup parent = part.ParentGroup; // parent.HasGroupChanged = true; // parent.ScheduleGroupForTerseUpdate(); part.ScheduleTerseUpdate(); } }
public void PlayfwdState(SceneObjectPart part) { if (part != null) { part.Undoing = true; if (part.ParentID == 0) { if (Position != Vector3.Zero) part.ParentGroup.AbsolutePosition = Position; if (Rotation != Quaternion.Identity) part.UpdateRotation(Rotation); if (Scale != Vector3.Zero) part.Resize(Scale); part.ParentGroup.ScheduleGroupForTerseUpdate(); } else { if (Position != Vector3.Zero) part.OffsetPosition = Position; if (Rotation != Quaternion.Identity) part.UpdateRotation(Rotation); if (Scale != Vector3.Zero) part.Resize(Scale); part.ScheduleTerseUpdate(); } part.Undoing = false; } }
public void PlaybackState(SceneObjectPart part) { part.Undoing = true; if (part.ParentID == 0) { // m_log.DebugFormat( // "[UNDO STATE]: Undoing position to {0} for root part {1} {2}", // Position, part.Name, part.LocalId); if (Position != Vector3.Zero) { if (ForGroup) part.ParentGroup.AbsolutePosition = Position; else part.ParentGroup.UpdateRootPosition(Position); } // m_log.DebugFormat( // "[UNDO STATE]: Undoing rotation {0} to {1} for root part {2} {3}", // part.RotationOffset, Rotation, part.Name, part.LocalId); if (ForGroup) part.UpdateRotation(Rotation); else part.ParentGroup.UpdateRootRotation(Rotation); if (Scale != Vector3.Zero) { // m_log.DebugFormat( // "[UNDO STATE]: Undoing scale {0} to {1} for root part {2} {3}", // part.Shape.Scale, Scale, part.Name, part.LocalId); if (ForGroup) part.ParentGroup.GroupResize(Scale); else part.Resize(Scale); } part.ParentGroup.ScheduleGroupForTerseUpdate(); } else { if (Position != Vector3.Zero) { // m_log.DebugFormat( // "[UNDO STATE]: Undoing position {0} to {1} for child part {2} {3}", // part.OffsetPosition, Position, part.Name, part.LocalId); part.OffsetPosition = Position; } // m_log.DebugFormat( // "[UNDO STATE]: Undoing rotation {0} to {1} for child part {2} {3}", // part.RotationOffset, Rotation, part.Name, part.LocalId); part.UpdateRotation(Rotation); if (Scale != Vector3.Zero) { // m_log.DebugFormat( // "[UNDO STATE]: Undoing scale {0} to {1} for child part {2} {3}", // part.Shape.Scale, Scale, part.Name, part.LocalId); part.Resize(Scale); } part.ScheduleTerseUpdate(); } part.Undoing = false; }