new public static RotorPartCollection Borrow(PartCollection parentCollection, Part originPart)
        {
            RotorPartCollection collection = BorrowWithoutAdding(parentCollection?.parentVessel, originPart);

            collection.parentCollection = parentCollection;
            collection.AddPart(originPart);
            return(collection);
        }
 private static void Reset(RotorPartCollection obj)
 {
     PartCollection.Reset(obj);
 }
        protected void AddPart(Part part)
        {
            if (parts.Count > 0 && part.HasModuleImplementing <Expansions.Serenity.ModuleRoboticServoRotor>())
            {
                partCollections.Add(RotorPartCollection.Borrow(parentVessel, part));
                return;
            }

            SimulatedPart simulatedPart = SimulatedPart.Borrow(part, parentVessel);

            parts.Add(simulatedPart);

            parentVessel.totalMass += simulatedPart.totalMass;
            parentVessel.dryMass   += simulatedPart.dryMass;
            parentVessel.CoM       += simulatedPart.totalMass * simulatedPart.CoM;
            parentVessel.CoM_dry   += simulatedPart.dryMass * simulatedPart.CoM;

            bool variableDragCube_Ctrl = false;

            ModuleLiftingSurface liftingSurface = part.FindModuleImplementing <ModuleLiftingSurface>();

            if (liftingSurface != null)
            {
                part.hasLiftModule = true;
                SimulatedLiftingSurface surface;
                if (liftingSurface is ModuleControlSurface ctrlSurface)
                {
                    surface = SimulatedControlSurface.Borrow(ctrlSurface, simulatedPart);
                    ctrls.Add((SimulatedControlSurface)surface);

                    // Controls change their drag cubes with deployment and so we can't precalculate them.
                    // The effect of their drag cubes is captured in the methods for SimulatedControlSurface
                    variableDragCube_Ctrl = true;

                    if (ctrlSurface.ctrlSurfaceArea < 1)
                    {
                        surface = SimulatedLiftingSurface.Borrow(ctrlSurface, simulatedPart);
                        surfaces.Add(surface);
                    }
                }
                else
                {
                    surface = SimulatedLiftingSurface.Borrow(liftingSurface, simulatedPart);
                    surfaces.Add(surface);
                }
                Math.Abs(0);
                parentVessel.relativeWingArea += surface.deflectionLiftCoeff * Math.Abs(surface.liftVector[1]);
            }

            List <ITorqueProvider> torqueProviders = part.FindModulesImplementing <ITorqueProvider>();

            // TODO: Add them to a list.

            if (part.inverseStage > parentVessel.stage)
            {
                // Recursively clear all engines - there's an earlier stage active.
                parentVessel.partCollection.ClearEngines();
                parentVessel.stage = part.inverseStage;
            }
            if (part.inverseStage >= parentVessel.stage)
            {
                MultiModeEngine multiMode = part.FindModuleImplementing <MultiModeEngine>();
                if (multiMode != null)
                {
                    engines.Add(SimulatedEngine.Borrow(part.FindModulesImplementing <ModuleEngines>().Find(engine => engine.engineID == multiMode.mode), simulatedPart));
                }
                else
                {
                    ModuleEngines engine = part.FindModulesImplementing <ModuleEngines>().FirstOrDefault();
                    if (engine != null)
                    {
                        engines.Add(SimulatedEngine.Borrow(engine, simulatedPart));
                    }
                }
            }

            if (variableDragCube_Ctrl)
            {
                simulatedPart.Release();
                parts.Remove(simulatedPart);
            }

            for (int i = part.children.Count - 1; i >= 0; i--)
            {
                AddPart(part.children[i]);
            }
        }