1 files changed, 622 insertions, 0 deletions

diff --git a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
new file mode 100755
index 0000000..2ba3c5a
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
@@ -0,0 +1,622 @@
+/*
+ * 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 copyrightD
+ *       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.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using Mono.Addins;
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class ExtendedPhysics : INonSharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[EXTENDED PHYSICS]";
+
+        // =============================================================
+        // Since BulletSim is a plugin, this these values aren't defined easily in one place.
+        // This table must correspond to an identical table in BSScene.
+
+        // Per scene functions. See BSScene.
+
+        // Per avatar functions. See BSCharacter.
+
+        // Per prim functions. See BSPrim.
+        public const string PhysFunctGetLinksetType = "BulletSim.GetLinksetType";
+        public const string PhysFunctSetLinksetType = "BulletSim.SetLinksetType";
+        public const string PhysFunctChangeLinkFixed = "BulletSim.ChangeLinkFixed";
+        public const string PhysFunctChangeLinkType = "BulletSim.ChangeLinkType";
+        public const string PhysFunctGetLinkType = "BulletSim.GetLinkType";
+        public const string PhysFunctChangeLinkParams = "BulletSim.ChangeLinkParams";
+        public const string PhysFunctAxisLockLimits = "BulletSim.AxisLockLimits";
+
+        // =============================================================
+
+        private IConfig Configuration { get; set; }
+        private bool Enabled { get; set; }
+        private Scene BaseScene { get; set; }
+        private IScriptModuleComms Comms { get; set; }
+
+        #region INonSharedRegionModule
+
+        public string Name { get { return this.GetType().Name; } }
+
+        public void Initialise(IConfigSource config)
+        {
+            BaseScene = null;
+            Enabled = false;
+            Configuration = null;
+            Comms = null;
+
+            try
+            {
+                if ((Configuration = config.Configs["ExtendedPhysics"]) != null)
+                {
+                    Enabled = Configuration.GetBoolean("Enabled", Enabled);
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("{0} Initialization error: {0}", LogHeader, e);
+            }
+
+            m_log.InfoFormat("{0} module {1} enabled", LogHeader, (Enabled ? "is" : "is not"));
+        }
+
+        public void Close()
+        {
+            if (BaseScene != null)
+            {
+                BaseScene.EventManager.OnObjectAddedToScene -= EventManager_OnObjectAddedToScene;
+                BaseScene.EventManager.OnSceneObjectPartUpdated -= EventManager_OnSceneObjectPartUpdated;
+                BaseScene = null;
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (BaseScene != null && BaseScene == scene)
+            {
+                Close();
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!Enabled) return;
+
+            BaseScene = scene;
+
+            Comms = BaseScene.RequestModuleInterface<IScriptModuleComms>();
+            if (Comms == null)
+            {
+                m_log.WarnFormat("{0} ScriptModuleComms interface not defined", LogHeader);
+                Enabled = false;
+
+                return;
+            }
+ 
+            // Register as LSL functions all the [ScriptInvocation] marked methods.
+            Comms.RegisterScriptInvocations(this);
+            Comms.RegisterConstants(this);
+
+            // When an object is modified, we might need to update its extended physics parameters
+            BaseScene.EventManager.OnObjectAddedToScene += EventManager_OnObjectAddedToScene;
+            BaseScene.EventManager.OnSceneObjectPartUpdated += EventManager_OnSceneObjectPartUpdated;
+
+        }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        #endregion // INonSharedRegionModule
+
+        private void EventManager_OnObjectAddedToScene(SceneObjectGroup obj)
+        {
+        }
+
+        // Event generated when some property of a prim changes.
+        private void EventManager_OnSceneObjectPartUpdated(SceneObjectPart sop, bool isFullUpdate)
+        {
+        }
+
+        [ScriptConstant]
+        public const int PHYS_CENTER_OF_MASS =     1 << 0;
+
+        [ScriptInvocation]
+        public string physGetEngineType(UUID hostID, UUID scriptID)
+        {
+            string ret = string.Empty;
+
+            if (BaseScene.PhysicsScene != null)
+            {
+                ret = BaseScene.PhysicsScene.EngineType;
+            }
+
+            return ret;
+        }
+
+        // Code for specifying params.
+        // The choice if 14700 is arbitrary and only serves to catch parameter code misuse.
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR     = 14700;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_X   = 14701;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_X  = 14702;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_Y   = 14703;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_Y  = 14704;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_Z   = 14705;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_Z  = 14706;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR    = 14707;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_X  = 14708;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_X = 14709;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_Y  = 14710;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_Y = 14711;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_Z  = 14712;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_Z = 14713;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR   = 14714;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_X = 14715;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_Y = 14716;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_Z = 14717;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR  = 14718;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_X = 14719;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_Y = 14720;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_Z = 14721;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK           = 14722;
+        // physAxisLockLimits()
+        [ScriptInvocation]
+        public int physAxisLock(UUID hostID, UUID scriptID, object[] parms)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            if (GetRootPhysActor(hostID, out rootPhysActor))
+            {
+                object[] parms2 = AddToBeginningOfArray(rootPhysActor, null, parms);
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctAxisLockLimits, parms2));
+            }
+
+            return ret;
+        }
+
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_CONSTRAINT  = 0;
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_COMPOUND    = 1;
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_MANUAL      = 2;
+
+        [ScriptInvocation]
+        public int physSetLinksetType(UUID hostID, UUID scriptID, int linksetType)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            // The part that is requesting the change.
+            SceneObjectPart requestingPart = BaseScene.GetSceneObjectPart(hostID);
+
+            if (requestingPart != null)
+            {
+                // The change is always made to the root of a linkset.
+                SceneObjectGroup containingGroup = requestingPart.ParentGroup;
+                SceneObjectPart rootPart = containingGroup.RootPart;
+
+                if (rootPart != null)
+                {
+                    PhysicsActor rootPhysActor = rootPart.PhysActor;
+                    if (rootPhysActor != null)
+                    {
+                        if (rootPhysActor.IsPhysical)
+                        {
+                            // Change a physical linkset by making non-physical, waiting for one heartbeat so all
+                            //    the prim and linkset state is updated, changing the type and making the
+                            //    linkset physical again.
+                            containingGroup.ScriptSetPhysicsStatus(false);
+                            Thread.Sleep(150);  // longer than one heartbeat tick
+
+                            // A kludge for the moment.
+                            // Since compound linksets move the children but don't generate position updates to the
+                            //     simulator, it is possible for compound linkset children to have out-of-sync simulator
+                            //     and physical positions. The following causes the simulator to push the real child positions
+                            //     down into the physics engine to get everything synced.
+                            containingGroup.UpdateGroupPosition(containingGroup.AbsolutePosition);
+                            containingGroup.UpdateGroupRotationR(containingGroup.GroupRotation);
+
+                            object[] parms2 = { rootPhysActor, null, linksetType };
+                            ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
+                            Thread.Sleep(150);  // longer than one heartbeat tick
+
+                            containingGroup.ScriptSetPhysicsStatus(true);
+                        }
+                        else
+                        {
+                            // Non-physical linksets don't have a physical instantiation so there is no state to
+                            //    worry about being updated.
+                            object[] parms2 = { rootPhysActor, null, linksetType };
+                            ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
+                        }
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} physSetLinksetType: root part does not have a physics actor. rootName={1}, hostID={2}",
+                                            LogHeader, rootPart.Name, hostID);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} physSetLinksetType: root part does not exist. RequestingPartName={1}, hostID={2}",
+                                        LogHeader, requestingPart.Name, hostID);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} physSetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+            return ret;
+        }
+
+        [ScriptInvocation]
+        public int physGetLinksetType(UUID hostID, UUID scriptID)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            if (GetRootPhysActor(hostID, out rootPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, null };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinksetType, parms2));
+            }
+            else
+            {
+                m_log.WarnFormat("{0} physGetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+            return ret;
+        }
+
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_FIXED  = 1234;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_HINGE  = 4;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_SPRING = 9;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_6DOF   = 6;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_SLIDER = 7;
+
+        // physChangeLinkType(integer linkNum, integer typeCode)
+        [ScriptInvocation]
+        public int physChangeLinkType(UUID hostID, UUID scriptID, int linkNum, int typeCode)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor, typeCode };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // physGetLinkType(integer linkNum)
+        [ScriptInvocation]
+        public int physGetLinkType(UUID hostID, UUID scriptID, int linkNum)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // physChangeLinkFixed(integer linkNum)
+        // Change the link between the root and the linkNum into a fixed, static physical connection.
+        [ScriptInvocation]
+        public int physChangeLinkFixed(UUID hostID, UUID scriptID, int linkNum)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor , PHYS_LINK_TYPE_FIXED };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // Code for specifying params.
+        // The choice if 14400 is arbitrary and only serves to catch parameter code misuse.
+        public const int PHYS_PARAM_MIN                    = 14401;
+
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINA_LOC           = 14401;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINA_ROT           = 14402;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINB_LOC           = 14403;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINB_ROT           = 14404;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINEAR_LIMIT_LOW       = 14405;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINEAR_LIMIT_HIGH      = 14406;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ANGULAR_LIMIT_LOW      = 14407;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ANGULAR_LIMIT_HIGH     = 14408;
+        [ScriptConstant]
+        public const int PHYS_PARAM_USE_FRAME_OFFSET       = 14409;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ENABLE_TRANSMOTOR      = 14410;
+        [ScriptConstant]
+        public const int PHYS_PARAM_TRANSMOTOR_MAXVEL      = 14411;
+        [ScriptConstant]
+        public const int PHYS_PARAM_TRANSMOTOR_MAXFORCE    = 14412;
+        [ScriptConstant]
+        public const int PHYS_PARAM_CFM                    = 14413;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ERP                    = 14414;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SOLVER_ITERATIONS      = 14415;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_AXIS_ENABLE     = 14416;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_DAMPING         = 14417;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_STIFFNESS       = 14418;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINK_TYPE              = 14419;
+        [ScriptConstant]
+        public const int PHYS_PARAM_USE_LINEAR_FRAMEA      = 14420;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_EQUILIBRIUM_POINT = 14421;
+
+        public const int PHYS_PARAM_MAX                    = 14421;
+
+        // Used when specifying a parameter that has settings for the three linear and three angular axis
+        [ScriptConstant]
+        public const int PHYS_AXIS_ALL = -1;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_ALL = -2;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_ALL = -3;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_X  = 0;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_Y  = 1;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_Z  = 2;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_X = 3;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_Y = 4;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_Z = 5;
+
+        // physChangeLinkParams(integer linkNum, [ PHYS_PARAM_*, value, PHYS_PARAM_*, value, ...])
+        [ScriptInvocation]
+        public int physChangeLinkParams(UUID hostID, UUID scriptID, int linkNum, object[] parms)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = AddToBeginningOfArray(rootPhysActor, childPhysActor, parms);
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkParams, parms2));
+            }
+
+            return ret;
+        }
+
+        private bool GetRootPhysActor(UUID hostID, out PhysicsActor rootPhysActor)
+        {
+            SceneObjectGroup containingGroup;
+            SceneObjectPart rootPart;
+            return GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor);
+        }
+
+        private bool GetRootPhysActor(UUID hostID, out SceneObjectGroup containingGroup, out SceneObjectPart rootPart, out PhysicsActor rootPhysActor)
+        {
+            bool ret = false;
+            rootPhysActor = null;
+            containingGroup = null;
+            rootPart = null;
+
+            SceneObjectPart requestingPart;
+
+            requestingPart = BaseScene.GetSceneObjectPart(hostID);
+            if (requestingPart != null)
+            {
+                // The type is is always on the root of a linkset.
+                containingGroup = requestingPart.ParentGroup;
+                if (containingGroup != null && !containingGroup.IsDeleted)
+                {
+                    rootPart = containingGroup.RootPart;
+                    if (rootPart != null)
+                    {
+                        rootPhysActor = rootPart.PhysActor;
+                        if (rootPhysActor != null)
+                        {
+                            ret = true;
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
+                                            LogHeader, rootPart.Name, hostID);
+                        }
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not exist. RequestingPartName={1}, hostID={2}",
+                                        LogHeader, requestingPart.Name, hostID);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Containing group missing or deleted. hostID={1}", LogHeader, hostID);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} GetRootAndChildPhysActors: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+
+            return ret;
+        }
+
+        // Find the root and child PhysActors based on the linkNum.
+        // Return 'true' if both are found and returned.
+        private bool GetRootAndChildPhysActors(UUID hostID, int linkNum, out PhysicsActor rootPhysActor, out PhysicsActor childPhysActor)
+        {
+            bool ret = false;
+            rootPhysActor = null;
+            childPhysActor = null;
+
+            SceneObjectGroup containingGroup;
+            SceneObjectPart rootPart;
+
+            if (GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor))
+            {
+                SceneObjectPart linkPart = containingGroup.GetLinkNumPart(linkNum);
+                if (linkPart != null)
+                {
+                    childPhysActor = linkPart.PhysActor;
+                    if (childPhysActor != null)
+                    {
+                        ret = true;
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} GetRootAndChildPhysActors: Link part has no physical actor. rootName={1}, hostID={2}, linknum={3}",
+                                            LogHeader, rootPart.Name, hostID, linkNum);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Could not find linknum part. rootName={1}, hostID={2}, linknum={3}",
+                                        LogHeader, rootPart.Name, hostID, linkNum);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
+                                LogHeader, rootPart.Name, hostID);
+            }
+
+            return ret;
+        }
+
+        // Return an array of objects with the passed object as the first object of a new array
+        private object[] AddToBeginningOfArray(object firstOne, object secondOne, object[] prevArray)
+        {
+            object[] newArray = new object[2 + prevArray.Length];
+            newArray[0] = firstOne;
+            newArray[1] = secondOne;
+            prevArray.CopyTo(newArray, 2);
+            return newArray;
+        }
+
+        // Extension() returns an object. Convert that object into the integer error we expect to return.
+        private int MakeIntError(object extensionRet)
+        {
+            int ret = -1;
+            if (extensionRet != null)
+            {
+                try
+                {
+                    ret = (int)extensionRet;
+                }
+                catch
+                {
+                    ret = -1;
+                }
+            }
+            return ret;
+        }
+    }
+}